Merge remote-tracking branch 'origin/streamline-testing' into streamline-testing

Author: Alexander Bainczyk

backend/src/main/java/de/learnlib/alex/data/dao/ProjectDAO.java

@@ -338,7 +338,10 @@ public Project importProject(User user, ProjectExportableEntity projectExportabl
 
         symbolGroupDAO.importGroups(user, createdProject, groups, new HashMap<>());
 
-        //todo:
+        /*  oldTestId -> newTestId
+         *  maps the exported testids to the corresponding newly created ones,
+         *  enabling correct referencing when importing testExecutionConfigs
+         */
         Map<Long, Long> configRefMap = new HashMap<>();
 
         if (!tests.isEmpty()) {

backend/src/main/java/de/learnlib/alex/data/dao/ProjectEnvironmentDAO.java

@@ -17,6 +17,7 @@
 package de.learnlib.alex.data.dao;
 
 import de.learnlib.alex.auth.entities.User;
+import de.learnlib.alex.common.exceptions.ForbiddenOperationException;
 import de.learnlib.alex.common.exceptions.NotFoundException;
 import de.learnlib.alex.data.entities.Project;
 import de.learnlib.alex.data.entities.ProjectEnvironment;
@@ -30,19 +31,20 @@
 import de.learnlib.alex.data.repositories.ProjectRepository;
 import de.learnlib.alex.data.repositories.ProjectUrlRepository;
 import de.learnlib.alex.data.repositories.SymbolActionRepository;
-import de.learnlib.alex.learning.entities.LearnerSetup;
 import de.learnlib.alex.learning.repositories.LearnerSetupRepository;
+import de.learnlib.alex.testing.repositories.TestExecutionConfigRepository;
 import de.learnlib.alex.testing.repositories.TestReportRepository;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-import javax.validation.ValidationException;
 import org.apache.shiro.authz.UnauthorizedException;
 import org.hibernate.Hibernate;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import javax.validation.ValidationException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
 @Service
 @Transactional(rollbackFor = Exception.class)
 public class ProjectEnvironmentDAO {
@@ -55,6 +57,7 @@ public class ProjectEnvironmentDAO {
     private final SymbolActionRepository symbolActionRepository;
     private final TestReportRepository testReportRepository;
     private final LearnerSetupRepository learnerSetupRepository;
+    private final TestExecutionConfigRepository testExecutionConfigRepository;
 
     @Autowired
     public ProjectEnvironmentDAO(ProjectDAO projectDAO,
@@ -64,7 +67,8 @@ public ProjectEnvironmentDAO(ProjectDAO projectDAO,
                                  ProjectUrlRepository urlRepository,
                                  SymbolActionRepository symbolActionRepository,
                                  TestReportRepository testReportRepository,
-                                 LearnerSetupRepository learnerSetupRepository) {
+                                 LearnerSetupRepository learnerSetupRepository,
+                                 TestExecutionConfigRepository testExecutionConfigRepository) {
         this.projectDAO = projectDAO;
         this.projectRepository = projectRepository;
         this.environmentRepository = environmentRepository;
@@ -73,6 +77,7 @@ public ProjectEnvironmentDAO(ProjectDAO projectDAO,
         this.symbolActionRepository = symbolActionRepository;
         this.testReportRepository = testReportRepository;
         this.learnerSetupRepository = learnerSetupRepository;
+        this.testExecutionConfigRepository = testExecutionConfigRepository;
     }
 
     public ProjectEnvironment create(User user, Long projectId, ProjectEnvironment environment) {
@@ -138,6 +143,14 @@ public void delete(User user, Long projectId, Long environmentId) {
             throw new ValidationException("There has to be at least one environment.");
         }
 
+        if (!testExecutionConfigRepository.findAllByProject_IdAndEnvironment_Id(projectId, environmentId).isEmpty()) {
+            throw new ForbiddenOperationException("The environment " +  environment.getName() + " is associated with one or more test configs.");
+        }
+
+        if (!learnerSetupRepository.findAllByProject_IdAndEnvironment_Id(projectId, environmentId).isEmpty()) {
+            throw new ForbiddenOperationException("The environment " +  environment.getName() + " is associated with one or more learner setups.");
+        }
+
         // select next best default environment
         if (environment.isDefault()) {
             final List<ProjectEnvironment> envs = environmentRepository.findAllByProject_Id(projectId);
@@ -149,18 +162,6 @@ public void delete(User user, Long projectId, Long environmentId) {
         // delete test reports that have been executed in the environment
         testReportRepository.deleteAllByEnvironment_Id(environment.getId());
 
-        // remove environment from learner setups
-        final List<LearnerSetup> learnerSetups = learnerSetupRepository.findAllByEnvironmentsContains(environment);
-        for (LearnerSetup learnerSetup : learnerSetups) {
-            learnerSetup.getEnvironments().remove(environment);
-            // switch to default environment if the deleted one is the only one
-            if (learnerSetup.getEnvironments().isEmpty()) {
-                final var defaultEnvironment = environmentRepository.findByProject_IdAndIs_Default(projectId, true);
-                learnerSetup.getEnvironments().add(defaultEnvironment);
-            }
-            learnerSetupRepository.save(learnerSetup);
-        }
-
         project.getEnvironments().remove(environment);
         projectRepository.save(project);
         environmentRepository.delete(environment);

backend/src/main/java/de/learnlib/alex/learning/repositories/LearnerSetupRepository.java

@@ -18,10 +18,13 @@
 
 import de.learnlib.alex.data.entities.ProjectEnvironment;
 import de.learnlib.alex.learning.entities.LearnerSetup;
-import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 @Repository
 public interface LearnerSetupRepository extends JpaRepository<LearnerSetup, Long> {
 
@@ -30,4 +33,9 @@ public interface LearnerSetupRepository extends JpaRepository<LearnerSetup, Long
     void deleteAllByProject_Id(Long projectId);
 
     List<LearnerSetup> findAllByEnvironmentsContains(ProjectEnvironment environment);
+
+    @Query(value = "select ls "
+            +      "from LearnerSetup ls join ls.environments e "
+            +      "where ls.project.id = :projectId and e.id = :environmentId")
+    List<LearnerSetup> findAllByProject_IdAndEnvironment_Id(@Param("projectId") Long projectId, @Param("environmentId") Long environmentId);
 }

backend/src/main/java/de/learnlib/alex/testing/dao/TestDAO.java

@@ -168,6 +168,10 @@ public Test create(User user, Long projectId, Test test) throws NotFoundExceptio
         return createByGenerate(user, project, test);
     }
 
+    public List<Test> create(User user, Long projectId, List<Test> tests) {
+        return create(user, projectId, tests, null);
+    }
+
     public List<Test> create(User user, Long projectId, List<Test> tests, Map<Long, Long> configRefMap) {
         return create(user, projectId, new ArrayList<>(tests), null, configRefMap);
     }

backend/src/main/java/de/learnlib/alex/testing/repositories/TestExecutionConfigRepository.java

@@ -45,4 +45,6 @@ public interface TestExecutionConfigRepository extends JpaRepository<TestExecuti
             +      "from TestExecutionConfig tc join tc.tests t "
             +      "where tc.project.id = :projectId and t.id = :testId")
     List<TestExecutionConfig> findAllByProject_IdAndTest_Id(@Param("projectId") Long projectId, @Param("testId") Long testId);
+
+    List<TestExecutionConfig> findAllByProject_IdAndEnvironment_Id(Long projectId, Long environmentId);
 }

backend/src/main/java/de/learnlib/alex/testing/rest/TestResource.java

@@ -115,7 +115,7 @@ public ResponseEntity<Test> createTest(@PathVariable("projectId") Long projectId
     public ResponseEntity<List<Test>> createTests(@PathVariable("projectId") Long projectId,
                                                   @RequestBody List<Test> tests) {
         final var user = authContext.getUser();
-        final var createdTests = testDAO.create(user, projectId, tests, null);
+        final var createdTests = testDAO.create(user, projectId, tests);
         webhookService.fireEvent(user, new TestEvent.CreatedMany(createdTests));
         return ResponseEntity.status(HttpStatus.CREATED).body(createdTests);
     }

backend/src/test/java/de/learnlib/alex/integrationtests/resources/ATestExecutionConfigResourceIT.java

@@ -16,16 +16,19 @@
 
 package de.learnlib.alex.integrationtests.resources;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import com.jayway.jsonpath.JsonPath;
 import de.learnlib.alex.integrationtests.resources.api.ProjectApi;
+import de.learnlib.alex.integrationtests.resources.api.TestApi;
 import de.learnlib.alex.integrationtests.resources.api.TestExecutionConfigApi;
 import de.learnlib.alex.integrationtests.resources.api.UserApi;
-import javax.ws.rs.core.Response;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import javax.ws.rs.core.Response;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class ATestExecutionConfigResourceIT extends AbstractResourceIT {
 
     private TestExecutionConfigApi api;
@@ -72,6 +75,20 @@ public void shouldCreateAConfig() throws Exception {
         assertEquals(1, getNumberOfConfigs(projectId1, jwtUser1));
     }
 
+    @Test
+    public void shouldCreateAConfigWithTests() throws Exception {
+        final TestApi testApi = new TestApi(client, port);
+
+        final String tc = "{\"name\": \"tc\", \"type\": \"case\"}";
+        final Response res1 = testApi.create(projectId1, tc, jwtUser1);
+        assertEquals(Response.Status.CREATED.getStatusCode(), res1.getStatus());
+
+        final int tcId = JsonPath.read(res1.readEntity(String.class), "$.id");
+        final Response res2 = api.create(projectId1, createConfigWithTests(projectId1, envId1, List.of((long) tcId)), jwtUser1);
+        assertEquals(Response.Status.CREATED.getStatusCode(), res2.getStatus());
+        assertEquals(1, getNumberOfConfigs(projectId1, jwtUser1));
+    }
+
     @Test
     public void shouldGetEmptyListIfNoConfigExists() throws Exception {
         final Response res = api.getAll(projectId1, jwtUser1);
@@ -145,7 +162,16 @@ private String createConfig(int projectId, int envId) {
         return "{"
                 + "\"tests\":[]"
                 + ",\"driverConfig\":{\"browser\":\"chrome\"}"
-                + ",\"environment\":" + envId
+                + ",\"environmentId\":" + envId
+                + ",\"project\":" + projectId
+                + "}";
+    }
+
+    private String createConfigWithTests(int projectId, int envId, List<Long> testIds) {
+        return "{"
+                + "\"tests\":" + testIds.toString()
+                + ",\"driverConfig\":{\"browser\":\"chrome\"}"
+                + ",\"environmentId\":" + envId
                 + ",\"project\":" + projectId
                 + "}";
     }

backend/src/test/resources/integrationtest/ALEX-rest.project.json

@@ -983,5 +983,6 @@
     }
   ],
   "formulaSuites": [],
-  "learnerSetups": []
+  "learnerSetups": [],
+  "testExecutionConfigs": []
 }