diff --git a/README.md b/README.md index 4595b92..111f360 100644 --- a/README.md +++ b/README.md @@ -129,6 +129,9 @@ Genmodels are not uploaded; they are generated from the metamodels. The pipeline (`model`, `consistency`, `vsum`), with a smoke test that creates and reloads the VSUM and compiles the constraints. 5. Runs `mvn clean verify`. +The generated VSUM registers the VitruvOCL constraints at the virtual model, so its Vitruv server lists, +validates, and manages them under `/vsum/constraints`, and validates them after every change propagation. + Invalid inputs are rejected with `400` before Maven runs (`VSUM_INPUT_ERROR`, `VSUM_METAMODEL_ERROR`, `VSUM_REACTIONS_ERROR`). Failed Maven builds are classified by their output, so that only problems of the uploads are reported as such: diff --git a/src/main/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildProperties.java b/src/main/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildProperties.java index 3e90985..3d7e229 100644 --- a/src/main/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildProperties.java +++ b/src/main/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildProperties.java @@ -14,8 +14,11 @@ @ConfigurationProperties(prefix = "setup.vsum") public class VsumBuildProperties { - /** Maven executable used to build the generated project. */ - private String mavenCommand = "mvn"; + /** Maven executable used to build the generated project; {@code mvn.cmd} on Windows. */ + private String mavenCommand = + System.getProperty("os.name", "").toLowerCase(java.util.Locale.ROOT).startsWith("windows") + ? "mvn.cmd" + : "mvn"; /** Additional Maven arguments, e.g. {@code -s settings.xml}. */ private List mavenArguments = new ArrayList<>(); @@ -67,24 +70,33 @@ public class VsumBuildProperties { // Vitruvius is released per repository, so the artifact groups can have different versions. - /** Version of the Vitruv-Change artifacts ({@code tools.vitruv.change.*}). */ - private String vitruvChangeVersion = "4.0.1"; + /** + * Version of the Vitruv-Change artifacts ({@code tools.vitruv.change.*}). It must provide the raw + * value of UUIDs, which the Vitruv server returns for violating elements. + */ + private String vitruvChangeVersion = "4.0.2-SNAPSHOT"; - /** Version of the Vitruv framework artifacts ({@code tools.vitruv.framework.*}). */ - private String vitruvFrameworkVersion = "4.0.1"; + /** + * Version of the Vitruv framework artifacts ({@code tools.vitruv.framework.*}). It must provide + * the constraint SPI ({@code tools.vitruv.framework.vsum.constraints}). + */ + private String vitruvFrameworkVersion = "4.0.2-SNAPSHOT"; /** Version of the Vitruv-DSLs artifacts ({@code tools.vitruv.dsls.*}, e.g. Reactions). */ private String vitruvDslsVersion = "4.0.0"; - /** Version of the Vitruv-Server artifacts ({@code tools.vitruv.server.*}). */ - private String vitruvServerVersion = "4.0.0"; + /** + * Version of the Vitruv-Server artifacts ({@code tools.vitruv.server.*}). It must provide the + * constraint endpoints ({@code /vsum/constraints}). + */ + private String vitruvServerVersion = "4.0.1-SNAPSHOT"; /** - * Version of VitruvOCL. It has no release yet, so a timestamped snapshot is pinned instead of - * {@code 0.1.0-SNAPSHOT}, which changes whenever a new snapshot is published. Snapshots are - * removed from the snapshot repository after a while; the Docker image keeps its copy. + * Version of VitruvOCL ({@code tools.vitruv:tools.vitruv.vitruvocl.language} from the + * VitruviusOCL repository). It has no release yet; pin a timestamped snapshot once one is + * published, so that builds do not change whenever a new snapshot is published. */ - private String vitruvoclVersion = "0.1.0-20261029.094026-91"; + private String vitruvoclVersion = "0.1.0-SNAPSHOT"; /** Version of {@code org.eclipse.emf.common}. */ private String emfCommonVersion = "2.46.0"; diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 5330061..8b6fdf3 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -9,7 +9,6 @@ spring.servlet.multipart.max-file-size=50MB spring.servlet.multipart.max-request-size=200MB # VSUM build (see VsumBuildProperties for all options) -setup.vsum.maven-command=mvn setup.vsum.build-timeout=15m setup.vsum.max-concurrent-builds=2 # offline builds with the Maven repository of the Docker image (see Dockerfile) diff --git a/src/main/resources/templates/vsum/rootPom.ftl b/src/main/resources/templates/vsum/rootPom.ftl index 5d1d530..6bcea88 100644 --- a/src/main/resources/templates/vsum/rootPom.ftl +++ b/src/main/resources/templates/vsum/rootPom.ftl @@ -91,8 +91,8 @@ - tools.vitruv.dsls - vitruvocl-language + tools.vitruv + tools.vitruv.vitruvocl.language ${vitruvocl.version} diff --git a/src/main/resources/templates/vsum/vsumMain.ftl b/src/main/resources/templates/vsum/vsumMain.ftl index 0c62246..03f2623 100644 --- a/src/main/resources/templates/vsum/vsumMain.ftl +++ b/src/main/resources/templates/vsum/vsumMain.ftl @@ -6,35 +6,36 @@ import java.io.InputStream; import java.io.UncheckedIOException; <#if constraintResources?has_content> -import java.nio.file.Files; +import java.nio.charset.StandardCharsets; import java.nio.file.Path; -<#if constraintResources?has_content> -import java.nio.file.StandardCopyOption; - import java.util.ArrayList; import java.util.Collection; +<#if constraintResources?has_content> +import java.util.LinkedHashMap; + import java.util.List; +<#if constraintResources?has_content> +import java.util.Map; + import java.util.Scanner; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl; -<#if constraintResources?has_content> -import tools.vitruv.change.atomic.uuid.Uuid; -import tools.vitruv.change.composite.description.PropagatedChange; -import tools.vitruv.change.composite.description.VitruviusChange; -import tools.vitruv.change.composite.propagation.ChangePropagationListener; - import tools.vitruv.change.propagation.ChangePropagationSpecification; import tools.vitruv.change.testutils.TestUserInteraction; <#if constraintResources?has_content> -import tools.vitruv.dsls.vitruvocl.pipeline.BatchValidationResult; -import tools.vitruv.dsls.vitruvocl.pipeline.ConstraintResult; -import tools.vitruv.dsls.vitruvocl.pipeline.VitruvOCL; +import tools.vitruv.dsls.vitruvocl.vitruv.VitruvOclConstraintChecker; import tools.vitruv.framework.remote.server.VitruvServer; import tools.vitruv.framework.views.ViewType; import tools.vitruv.framework.views.ViewTypeFactory; import tools.vitruv.framework.vsum.VirtualModelBuilder; +<#if constraintResources?has_content> +import tools.vitruv.framework.vsum.constraints.ConstraintValidationListener.Trigger; +import tools.vitruv.framework.vsum.constraints.ConstraintValidationReport; +import tools.vitruv.framework.vsum.constraints.ConstraintValidationResult; +import tools.vitruv.framework.vsum.constraints.InvalidConstraintException; + import tools.vitruv.framework.vsum.internal.InternalVirtualModel; /** @@ -95,9 +96,19 @@ public class [=vsumMainClass] { new TestUserInteraction.ResultProvider(new TestUserInteraction())) .withChangePropagationSpecifications(createChangePropagationSpecifications()) .withViewTypes(createViewTypes()) +<#if constraintResources?has_content> + // the Vitruv server lists, validates and manages the constraints via REST + .withConstraintChecker(createConstraintChecker()) + .withConstraintValidationAfterPropagation(true) + .buildAndInitialize(); <#if constraintResources?has_content> - registerConstraintEvaluation(vsum); + vsum.addConstraintValidationListener( + (report, trigger) -> { + if (trigger == Trigger.PROPAGATION) { + reportViolations(report); + } + }); return vsum; } @@ -133,86 +144,85 @@ public class [=vsumMainClass] { } <#if constraintResources?has_content> - /** Evaluates all constraints after every change propagation and reports violations. */ - static void registerConstraintEvaluation(InternalVirtualModel vsum) { - VitruvOCL.registerVSUM(vsum); - vsum.addChangePropagationListener( - new ChangePropagationListener() { - @Override - public void startedChangePropagation(VitruviusChange changeToPropagate) { - // constraints are evaluated once all reactions have been executed - } - - @Override - public void finishedChangePropagation(Iterable propagatedChanges) { - for (String resource : CONSTRAINT_RESOURCES) { - BatchValidationResult result = evaluateConstraints(resource); - result - .getViolatedConstraints() - .forEach( - violation -> - System.err.println( - "[OCL VIOLATION] " - + violation.getConstraint() - + ": " - + violation.getWarningsSummary())); - if (!result.allSucceeded()) { - System.err.println("[OCL ERROR] " + resource + ":\n" + describeFailures(result)); - } - } - } - }); + /** + * Creates the checker of the VitruvOCL constraints of this VSUM. + * + * @return the checker of all constraint resources + * @throws IllegalArgumentException if a constraint resource cannot be parsed, described as by + * {@link #describeFailures} + */ + static VitruvOclConstraintChecker createConstraintChecker() { + for (String resource : CONSTRAINT_RESOURCES) { + try { + VitruvOclConstraintChecker.fromClasspath(resource); + } catch (InvalidConstraintException e) { + List lines = readResource(resource).lines().toList(); + Map> errors = new LinkedHashMap<>(); + e.getDiagnostics() + .forEach( + diagnostic -> + errors + .computeIfAbsent( + diagnostic.line() >= 1 && diagnostic.line() <= lines.size() + ? lines.get(diagnostic.line() - 1).strip() + : resource, + line -> new ArrayList<>()) + .add( + diagnostic.line() + + ":" + + diagnostic.column() + + " " + + diagnostic.message())); + throw new IllegalArgumentException(describeFailures(resource, errors), e); + } + } + return VitruvOclConstraintChecker.fromClasspath(CONSTRAINT_RESOURCES.toArray(String[]::new)); } /** - * Evaluates the constraints of a classpath resource against the registered VSUM. + * Describes constraints of a resource that cannot be evaluated, in the form the setup service + * attributes to the uploaded constraint file. * - * @param resource classpath resource of an {@code .ocl} file - * @return the evaluation result + * @param resource the classpath resource of the constraints + * @param errors the errors per constraint (its source or the faulty line) + * @return the description */ - static BatchValidationResult evaluateConstraints(String resource) { - try { - Path file = Files.createTempFile("constraints", ".ocl"); - try (InputStream input = - [=vsumMainClass].class.getClassLoader().getResourceAsStream(resource)) { - if (input == null) { - throw new IllegalStateException("Constraint resource not found: " + resource); - } - Files.copy(input, file, StandardCopyOption.REPLACE_EXISTING); - return VitruvOCL.evaluateConstraints(file); - } finally { - Files.deleteIfExists(file); - } + static String describeFailures(String resource, Map> errors) { + StringBuilder description = + new StringBuilder("Constraints in " + resource + " cannot be evaluated:\n"); + errors.forEach( + (constraint, constraintErrors) -> { + description.append("- ").append(constraint.replaceAll("\\s+", " ")).append('\n'); + constraintErrors.forEach(error -> description.append(" ").append(error).append('\n')); + }); + return description.toString(); + } + + private static String readResource(String resource) { + try (InputStream input = + [=vsumMainClass].class.getClassLoader().getResourceAsStream(resource)) { + return input == null ? "" : new String(input.readAllBytes(), StandardCharsets.UTF_8); } catch (IOException e) { throw new UncheckedIOException(e); } } /** - * Describes the constraints that could not be compiled or evaluated. + * Reports the constraints violated after a change propagation. The Vitruv server offers the + * full results, including the violating elements, under {@code /vsum/constraints/validate}. * - * @param result an evaluation result - * @return one entry per failed constraint with its errors + * @param report the validation result of all constraints */ - static String describeFailures(BatchValidationResult result) { - StringBuilder description = new StringBuilder(); - for (ConstraintResult failure : result.getFailedConstraints()) { - description - .append("- ") - .append(failure.getConstraint().strip().replaceAll("\\s+", " ")) - .append('\n'); - failure - .getCompilerErrors() + static void reportViolations(ConstraintValidationReport report) { + for (ConstraintValidationResult result : report.getUnsatisfiedResults()) { + String id = result.descriptor().id(); + result + .violations() .forEach( - error -> - description.append( - String.format( - " %d:%d %s%n", error.getLine(), error.getColumn(), error.getMessage()))); - failure - .getFileErrors() - .forEach(error -> description.append(" ").append(error.getMessage()).append('\n')); + violation -> + System.err.println("[OCL VIOLATION] " + id + ": " + violation.message())); + result.errors().forEach(error -> System.err.println("[OCL ERROR] " + id + ": " + error)); } - return description.toString(); } } diff --git a/src/main/resources/templates/vsum/vsumPom.ftl b/src/main/resources/templates/vsum/vsumPom.ftl index 8dd7f11..b25b268 100644 --- a/src/main/resources/templates/vsum/vsumPom.ftl +++ b/src/main/resources/templates/vsum/vsumPom.ftl @@ -61,8 +61,8 @@ - tools.vitruv.dsls - vitruvocl-language + tools.vitruv + tools.vitruv.vitruvocl.language diff --git a/src/main/resources/templates/vsum/vsumTest.ftl b/src/main/resources/templates/vsum/vsumTest.ftl index bf39fb2..17b1417 100644 --- a/src/main/resources/templates/vsum/vsumTest.ftl +++ b/src/main/resources/templates/vsum/vsumTest.ftl @@ -5,8 +5,17 @@ import java.nio.file.Path; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; <#if constraintResources?has_content> +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; +import java.util.List; +import java.util.stream.Collectors; import org.junit.jupiter.api.Assertions; -import tools.vitruv.dsls.vitruvocl.pipeline.BatchValidationResult; +import tools.vitruv.dsls.vitruvocl.vitruv.VitruvOclConstraintChecker; +import tools.vitruv.framework.vsum.constraints.ConstraintDescriptor; +import tools.vitruv.framework.vsum.constraints.ConstraintStatus; +import tools.vitruv.framework.vsum.constraints.ConstraintValidationReport; +import tools.vitruv.framework.vsum.constraints.ConstraintValidationResult; import tools.vitruv.framework.vsum.internal.InternalVirtualModel; @@ -27,15 +36,24 @@ class [=vsumMainClass]Test { void constraintsCanBeEvaluated(@TempDir Path storageFolder) throws IOException { InternalVirtualModel vsum = [=vsumMainClass].createVirtualModel(storageFolder); try { + Assertions.assertEquals( + [=vsumMainClass].createConstraintChecker().getConstraints().size(), + vsum.getConstraints().size(), + "the VSUM registers all constraints"); + ConstraintValidationReport report = vsum.validateConstraints(); for (String resource : [=vsumMainClass].CONSTRAINT_RESOURCES) { - BatchValidationResult result = [=vsumMainClass].evaluateConstraints(resource); + Set ids = + VitruvOclConstraintChecker.fromClasspath(resource).getConstraints().stream() + .map(ConstraintDescriptor::id) + .collect(Collectors.toSet()); + Map> errors = new LinkedHashMap<>(); + for (ConstraintValidationResult result : report.results()) { + if (result.status() == ConstraintStatus.ERROR && ids.contains(result.descriptor().id())) { + errors.put(result.descriptor().source(), result.errors()); + } + } Assertions.assertTrue( - result.allSucceeded(), - () -> - "Constraints in " - + resource - + " cannot be evaluated:\n" - + [=vsumMainClass].describeFailures(result)); + errors.isEmpty(), () -> [=vsumMainClass].describeFailures(resource, errors)); } } finally { vsum.dispose(); diff --git a/src/main/resources/vsum-sample/constraints.ocl b/src/main/resources/vsum-sample/constraints.ocl index 65bb86e..1f17887 100644 --- a/src/main/resources/vsum-sample/constraints.ocl +++ b/src/main/resources/vsum-sample/constraints.ocl @@ -1,7 +1,7 @@ -- VitruviusOCL Constraint File for the Methodologist Template -- -- This file defines cross-model consistency constraints between model and model2. --- Constraints are evaluated against the VSUM via VitruvOCL.evaluateConstraints(path). +-- The generated VSUM registers the constraints, so its Vitruv server lists and validates them. -- -- Syntax notes (OCL#): -- - context :: inv : diff --git a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildEndToEndTest.java b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildEndToEndTest.java new file mode 100644 index 0000000..d544637 --- /dev/null +++ b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumBuildEndToEndTest.java @@ -0,0 +1,119 @@ +package tools.vitruv.methodologist.setup.vsum.service; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static tools.vitruv.methodologist.setup.vsum.service.TestFiles.fixture; + +import java.io.IOException; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.Duration; +import java.time.Instant; +import java.util.List; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfSystemProperty; +import org.junit.jupiter.api.io.TempDir; +import tools.vitruv.methodologist.setup.vsum.service.build.MavenBuildRunner; +import tools.vitruv.methodologist.setup.vsum.service.constraints.ConstraintsProcessor; +import tools.vitruv.methodologist.setup.vsum.service.metamodel.MetamodelProcessor; +import tools.vitruv.methodologist.setup.vsum.service.project.ProjectGenerator; +import tools.vitruv.methodologist.setup.vsum.service.reactions.ReactionsProcessor; +import tools.vitruv.methodologist.setup.vsum.service.views.NeoJoinViewDefinitionProcessor; + +/** + * Builds a VSUM with constraints, starts it and checks that its Vitruv server lists and validates + * the uploaded constraints. Runs the real Maven build and needs port 8080, so it only runs with + * {@code -Dvsum.integration=true}. + */ +@EnabledIfSystemProperty(named = "vsum.integration", matches = "true") +class VsumBuildEndToEndTest { + private static final String SERVER_URL = "http://localhost:8080"; + + private final VsumBuildProperties properties = new VsumBuildProperties(); + private final VsumProjectBuildService service = + new VsumProjectBuildService( + new MetamodelProcessor(), + new ReactionsProcessor(), + new ConstraintsProcessor(), + new NeoJoinViewDefinitionProcessor(), + new ProjectGenerator(properties), + new MavenBuildRunner(properties), + properties); + + @TempDir Path runDirectory; + + @Test + void builtVsumServesTheUploadedConstraints() throws Exception { + byte[] jar = + service.buildProjectJar( + new VsumBuildRequest( + List.of(fixture("model.ecore"), fixture("model2.ecore")), + List.of(fixture("templateReactions.reactions")), + List.of(fixture("constraints.ocl")), + List.of())); + + Path jarFile = Files.write(runDirectory.resolve("vsum.jar"), jar); + Process server = + new ProcessBuilder("java", "-jar", jarFile.toString()) + .directory(runDirectory.toFile()) + .redirectErrorStream(true) + .redirectOutput(runDirectory.resolve("server.log").toFile()) + .start(); + try { + HttpClient http = HttpClient.newHttpClient(); + awaitHealthy(http, server); + + HttpResponse constraints = send(http, request("/vsum/constraints").GET()); + assertEquals(200, constraints.statusCode()); + assertTrue( + constraints.body().contains("\"model::Component::ComponentHasCorrespondingEntity\""), + constraints.body()); + + HttpResponse validation = + send( + http, + request("/vsum/constraints/validate") + .header("Content-Type", "application/json") + .POST(HttpRequest.BodyPublishers.ofString("{}"))); + assertEquals(200, validation.statusCode()); + assertTrue(validation.body().contains("\"satisfied\" : true"), validation.body()); + } finally { + server.destroy(); + if (!server.waitFor(10, TimeUnit.SECONDS)) { + server.destroyForcibly(); + } + } + } + + private static void awaitHealthy(HttpClient http, Process server) throws Exception { + Instant deadline = Instant.now().plus(Duration.ofMinutes(2)); + while (Instant.now().isBefore(deadline)) { + if (!server.isAlive()) { + throw new IllegalStateException("VSUM server terminated with " + server.exitValue()); + } + try { + if (send(http, request("/health").GET()).statusCode() == 200) { + return; + } + } catch (IOException notYetStarted) { + // the server is still starting + } + Thread.sleep(500); + } + throw new IllegalStateException("VSUM server did not start"); + } + + private static HttpResponse send(HttpClient http, HttpRequest.Builder request) + throws IOException, InterruptedException { + return http.send(request.build(), HttpResponse.BodyHandlers.ofString()); + } + + private static HttpRequest.Builder request(String path) { + return HttpRequest.newBuilder(URI.create(SERVER_URL + path)).timeout(Duration.ofSeconds(10)); + } +} diff --git a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumProjectBuildServiceTest.java b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumProjectBuildServiceTest.java index 92bff89..b39b462 100644 --- a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumProjectBuildServiceTest.java +++ b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/VsumProjectBuildServiceTest.java @@ -91,7 +91,8 @@ void generatesAProjectFollowingTheMethodologistTemplate() throws IOException { String rootPom = Files.readString(projectRoot.resolve("pom.xml")); assertTrue(rootPom.contains("${vitruv.change.version}"), rootPom); - assertTrue(rootPom.contains("4.0.1"), rootPom); + assertTrue( + rootPom.contains("4.0.2-SNAPSHOT"), rootPom); assertTrue(rootPom.contains("4.0.0"), rootPom); String workflow = Files.readString(projectRoot.resolve("model/workflow/generate.mwe2")); @@ -114,9 +115,11 @@ void generatesAProjectFollowingTheMethodologistTemplate() throws IOException { main); assertTrue( main.contains("\"tools/vitruv/methodologisttemplate/consistency/constraints.ocl\""), main); + assertTrue(main.contains(".withConstraintChecker(createConstraintChecker())"), main); assertTrue( - Files.readString(projectRoot.resolve("vsum/pom.xml")).contains("vitruvocl-language")); + Files.readString(projectRoot.resolve("vsum/pom.xml")) + .contains("tools.vitruv.vitruvocl.language")); } @ParameterizedTest @@ -171,7 +174,8 @@ void leavesOutVitruvOclWithoutConstraints() throws IOException { service.generateProject(request, projectRoot); assertFalse( - Files.readString(projectRoot.resolve("vsum/pom.xml")).contains("vitruvocl-language")); + Files.readString(projectRoot.resolve("vsum/pom.xml")) + .contains("tools.vitruv.vitruvocl.language")); String main = Files.readString( projectRoot.resolve( diff --git a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/build/MavenBuildRunnerTest.java b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/build/MavenBuildRunnerTest.java index 0d7bdbb..adc583a 100644 --- a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/build/MavenBuildRunnerTest.java +++ b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/build/MavenBuildRunnerTest.java @@ -127,7 +127,7 @@ void buildsOfflineWithTheConfiguredRepositoryAndLocksIt() { assertEquals( List.of( - "mvn", + properties.getMavenCommand(), "--batch-mode", "--no-transfer-progress", "--offline", diff --git a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/project/ProjectGeneratorTest.java b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/project/ProjectGeneratorTest.java index 0932de8..abf843d 100644 --- a/src/test/java/tools/vitruv/methodologist/setup/vsum/service/project/ProjectGeneratorTest.java +++ b/src/test/java/tools/vitruv/methodologist/setup/vsum/service/project/ProjectGeneratorTest.java @@ -30,7 +30,8 @@ class ProjectGeneratorTest { "tools.vitruv.change.", "${vitruv.change.version}", "tools.vitruv.framework.", "${vitruv.framework.version}", "tools.vitruv.dsls.", "${vitruv.dsls.version}", - "tools.vitruv.server.", "${vitruv.server.version}"); + "tools.vitruv.server.", "${vitruv.server.version}", + "tools.vitruv.vitruvocl.", "${vitruvocl.version}"); private static final List METAMODELS = List.of(