Merge branch 'streamline-testing' into developer

Author: Alexander Bainczyk

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

@@ -46,8 +46,10 @@
 import de.learnlib.alex.modelchecking.entities.LtsFormula;
 import de.learnlib.alex.modelchecking.entities.LtsFormulaSuite;
 import de.learnlib.alex.testing.dao.TestDAO;
+import de.learnlib.alex.testing.dao.TestExecutionConfigDAO;
 import de.learnlib.alex.testing.dao.TestReportDAO;
 import de.learnlib.alex.testing.entities.Test;
+import de.learnlib.alex.testing.entities.TestExecutionConfig;
 import de.learnlib.alex.testing.entities.TestSuite;
 import de.learnlib.alex.testing.repositories.TestExecutionConfigRepository;
 import de.learnlib.alex.testing.repositories.TestReportRepository;
@@ -60,6 +62,7 @@
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import javax.validation.ValidationException;
 import org.apache.shiro.authz.UnauthorizedException;
@@ -106,6 +109,7 @@ public class ProjectDAO {
     private final LtsFormulaDAO ltsFormulaDAO;
     private final LearnerResultStepRepository learnerResultStepRepository;
     private final LearnerSetupDAO learnerSetupDAO;
+    private final TestExecutionConfigDAO testExecutionConfigDAO;
 
     @Autowired
     public ProjectDAO(ProjectRepository projectRepository,
@@ -133,8 +137,8 @@ public ProjectDAO(ProjectRepository projectRepository,
                       @Lazy TestReportDAO testReportDAO,
                       @Lazy LtsFormulaSuiteDAO ltsFormulaSuiteDAO,
                       @Lazy LtsFormulaDAO ltsFormulaDAO,
-                      @Lazy LearnerSetupDAO learnerSetupDAO
-    ) {
+                      @Lazy LearnerSetupDAO learnerSetupDAO,
+                      @Lazy TestExecutionConfigDAO testExecutionConfigDAO) {
         this.projectRepository = projectRepository;
         this.learnerResultRepository = learnerResultRepository;
         this.fileDAO = fileDAO;
@@ -161,6 +165,7 @@ public ProjectDAO(ProjectRepository projectRepository,
         this.ltsFormulaDAO = ltsFormulaDAO;
         this.learnerResultStepRepository = learnerResultStepRepository;
         this.learnerSetupDAO = learnerSetupDAO;
+        this.testExecutionConfigDAO = testExecutionConfigDAO;
     }
 
     public Project create(final User user, final CreateProjectForm projectForm) {
@@ -243,13 +248,13 @@ public void delete(User user, Long projectId) {
 
         symbolActionRepository.deleteAllBySymbol_Project_Id(projectId);
         symbolStepRepository.deleteAllBySymbol_Project_Id(projectId);
+        testExecutionConfigRepository.deleteAllByProject_Id(projectId);
         testReportRepository.deleteAllByProject_Id(projectId);
         testRepository.deleteAllByProject_Id(projectId);
         learnerResultStepRepository.deleteAllByResult_Project_Id(projectId);
         learnerResultRepository.deleteAllByProject_Id(projectId);
         learnerSetupRepository.deleteAllByProject_Id(projectId);
         parameterizedSymbolRepository.deleteAllBySymbol_Project_Id(projectId);
-        testExecutionConfigRepository.deleteAllByProject_Id(projectId);
         symbolParameterRepository.deleteAllBySymbol_Project_Id(projectId);
         uploadableFileRepository.deleteAllByProject_Id(projectId);
 
@@ -290,13 +295,15 @@ public Project importProject(User user, ProjectExportableEntity projectExportabl
         final List<Test> tests;
         final List<LtsFormulaSuite> formulaSuites;
         final List<LearnerSetup> learnerSetups;
+        final List<TestExecutionConfig> testExecutionConfigs;
 
         try {
             project = om.readValue(projectExportableEntity.getProject().toString(), Project.class);
             groups = Arrays.asList(om.readValue(projectExportableEntity.getGroups().toString(), SymbolGroup[].class));
             tests = Arrays.asList(om.readValue(projectExportableEntity.getTests().toString(), Test[].class));
             formulaSuites = Arrays.asList(om.readValue(projectExportableEntity.getFormulaSuites().toString(), LtsFormulaSuite[].class));
             learnerSetups = Arrays.asList(om.readValue(projectExportableEntity.getLearnerSetups().toString(), LearnerSetup[].class));
+            testExecutionConfigs = Arrays.asList(om.readValue(projectExportableEntity.getTestExecutionConfigs().toString(), TestExecutionConfig[].class));
         } catch (IOException e) {
             e.printStackTrace();
             throw new ValidationException("The input is not formatted correctly");
@@ -331,8 +338,14 @@ public Project importProject(User user, ProjectExportableEntity projectExportabl
 
         symbolGroupDAO.importGroups(user, createdProject, groups, new HashMap<>());
 
+        /*  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()) {
-            testDAO.importTests(user, createdProject.getId(), tests);
+            testDAO.importTests(user, createdProject.getId(), tests, configRefMap);
         }
 
         for (LtsFormulaSuite suite : formulaSuites) {
@@ -346,6 +359,10 @@ public Project importProject(User user, ProjectExportableEntity projectExportabl
             learnerSetupDAO.importLearnerSetups(user, createdProject, learnerSetups);
         }
 
+        if (!testExecutionConfigs.isEmpty()) {
+            testExecutionConfigDAO.importTestExecutionConfigs(user, createdProject, testExecutionConfigs, configRefMap);
+        }
+
         loadLazyRelations(createdProject);
         return createdProject;
     }

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,8 +31,8 @@
 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;
@@ -55,6 +56,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 +66,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 +76,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 +142,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 +161,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/data/entities/export/ProjectExportableEntity.java

@@ -30,6 +30,8 @@ public class ProjectExportableEntity extends ExportableEntity {
 
     private JsonNode learnerSetups;
 
+    private JsonNode testExecutionConfigs;
+
     public ProjectExportableEntity() {
         super("-1", "project");
     }
@@ -78,4 +80,12 @@ public JsonNode getLearnerSetups() {
     public void setLearnerSetups(JsonNode learnerSetups) {
         this.learnerSetups = learnerSetups;
     }
+
+    public JsonNode getTestExecutionConfigs() {
+        return testExecutionConfigs;
+    }
+
+    public void setTestExecutionConfigs(JsonNode testExecutionConfigs) {
+        this.testExecutionConfigs = testExecutionConfigs;
+    }
 }

backend/src/main/java/de/learnlib/alex/data/repositories/ProjectEnvironmentRepository.java

@@ -37,4 +37,6 @@ public interface ProjectEnvironmentRepository extends JpaRepository<ProjectEnvir
     List<ProjectEnvironment> findAllByIdIn(List<Long> ids);
 
     List<ProjectEnvironment> findByProject_IdAndNameIn(Long projectId, List<String> names);
+
+    ProjectEnvironment findByProject_IdAndId(Long projectId, Long environmentId);
 }

backend/src/main/java/de/learnlib/alex/data/services/export/ProjectExporter.java

@@ -28,8 +28,10 @@
 import de.learnlib.alex.data.entities.export.SymbolGroupsExportableEntity;
 import de.learnlib.alex.learning.entities.export.LearnerSetupExportableEntity;
 import de.learnlib.alex.learning.services.export.LearnerSetupsExporter;
+import de.learnlib.alex.learning.services.export.TestExecutionConfigsExporter;
 import de.learnlib.alex.modelchecking.entities.export.LtsFormulaSuitesExportableEntity;
 import de.learnlib.alex.modelchecking.services.export.LtsFormulaSuitesExporter;
+import de.learnlib.alex.testing.entities.export.TestExecutionConfigExportableEntity;
 import de.learnlib.alex.testing.entities.export.TestsExportableEntity;
 import de.learnlib.alex.testing.services.export.TestsExporter;
 import java.util.List;
@@ -46,20 +48,23 @@ public class ProjectExporter extends EntityExporter {
     private final TestsExporter testsExporter;
     private final LtsFormulaSuitesExporter formulaSuitesExporter;
     private final LearnerSetupsExporter learnerSetupsExporter;
+    private final TestExecutionConfigsExporter testExecutionConfigsExporter;
 
     @Autowired
     public ProjectExporter(
             ProjectDAO projectDAO,
             SymbolsExporter symbolsExporter,
             TestsExporter testsExporter,
             LtsFormulaSuitesExporter formulaSuitesExporter,
-            LearnerSetupsExporter learnerSetupsExporter
+            LearnerSetupsExporter learnerSetupsExporter,
+            TestExecutionConfigsExporter testExecutionConfigsExporter
     ) {
         this.projectDAO = projectDAO;
         this.symbolsExporter = symbolsExporter;
         this.testsExporter = testsExporter;
         this.formulaSuitesExporter = formulaSuitesExporter;
         this.learnerSetupsExporter = learnerSetupsExporter;
+        this.testExecutionConfigsExporter = testExecutionConfigsExporter;
     }
 
     public ExportableEntity export(User user, Long projectId) throws Exception {
@@ -75,6 +80,7 @@ public ExportableEntity export(User user, Long projectId) throws Exception {
         exportableEntity.setTests(((TestsExportableEntity) testsExporter.exportAll(user, projectId)).getTests());
         exportableEntity.setFormulaSuites(((LtsFormulaSuitesExportableEntity) formulaSuitesExporter.export(user, projectId)).getFormulaSuites());
         exportableEntity.setLearnerSetups(((LearnerSetupExportableEntity) learnerSetupsExporter.export(user, projectId)).getLearnerSetups());
+        exportableEntity.setTestExecutionConfigs(((TestExecutionConfigExportableEntity) testExecutionConfigsExporter.export(user, projectId)).getTestConfigs());
 
         return exportableEntity;
     }

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

@@ -16,10 +16,11 @@
 
 package de.learnlib.alex.learning.repositories;
 
-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;
 
 @Repository
@@ -29,5 +30,8 @@ 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/learning/rest/LearnerSetupResource.java

@@ -32,7 +32,6 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.transaction.annotation.Transactional;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -45,7 +44,6 @@
 
 @RestController
 @RequestMapping("/rest/projects/{projectId}/learner/setups")
-@Transactional(rollbackFor = Exception.class)
 public class LearnerSetupResource {
 
     private final AuthContext authContext;