From 5ed31be4cfcc065255618708428dcb2c2b87c712 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Giraudet?= Date: Thu, 29 Jan 2026 13:54:16 +0100 Subject: [PATCH] [cleanup] Inline StepVerifier logic in GVBCAUTests & GVBCAUTests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Théo Giraudet --- ...va => ConnectorAsUsageCheckerBuilder.java} | 46 +- .../view/GVBindingConnectorAsUsageTests.java | 265 ++++++---- .../view/GVConnectionUsageEdgeTests.java | 474 ++++++++++++------ .../diagrams/testers/DirectEditTester.java | 105 +++- 4 files changed, 595 insertions(+), 295 deletions(-) rename backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/{ConnectorAsUsageChecker.java => ConnectorAsUsageCheckerBuilder.java} (70%) diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/ConnectorAsUsageChecker.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/ConnectorAsUsageCheckerBuilder.java similarity index 70% rename from backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/ConnectorAsUsageChecker.java rename to backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/ConnectorAsUsageCheckerBuilder.java index 534553478..c6aa8f873 100644 --- a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/ConnectorAsUsageChecker.java +++ b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/checkers/ConnectorAsUsageCheckerBuilder.java @@ -17,21 +17,18 @@ import java.util.List; import java.util.concurrent.atomic.AtomicReference; -import org.eclipse.sirius.components.collaborative.diagrams.dto.DiagramRefreshedEventPayload; import org.eclipse.sirius.components.core.api.IIdentityService; import org.eclipse.syson.application.controller.editingContext.checkers.SemanticCheckerService; import org.eclipse.syson.sysml.ConnectorAsUsage; import org.eclipse.syson.sysml.FeatureChaining; -import reactor.test.StepVerifier.Step; - /** - * Checker that verify semantic of a {@link org.eclipse.syson.sysml.ConnectorAsUsage}. + * Builder for a checker that verify semantic of a {@link org.eclipse.syson.sysml.ConnectorAsUsage}. * * @param Type of {@link ConnectorAsUsage} to check. * @author Arthur Daussy */ -public class ConnectorAsUsageChecker { +public class ConnectorAsUsageCheckerBuilder { private String expectedSourceSemanticId; @@ -49,57 +46,56 @@ public class ConnectorAsUsageChecker { private final IIdentityService identityService; - private final SemanticCheckerService semanticCheckerService; - private final Class expectedType; - public ConnectorAsUsageChecker( + private final SemanticCheckerService semanticCheckerService; + + public ConnectorAsUsageCheckerBuilder( IIdentityService identityService, - SemanticCheckerService semanticCheckerService, - Class expectedType) { + Class expectedType, + SemanticCheckerService semanticCheckerService) { this.identityService = identityService; - this.semanticCheckerService = semanticCheckerService; this.expectedType = expectedType; + this.semanticCheckerService = semanticCheckerService; } - public ConnectorAsUsageChecker setExpectedSemanticContainer(String anExpectedSemanticContainer) { + public ConnectorAsUsageCheckerBuilder setExpectedSemanticContainer(String anExpectedSemanticContainer) { this.expectedSemanticContainer = anExpectedSemanticContainer; return this; } - public ConnectorAsUsageChecker setExpectedSourceFeatureChain(List anExpectedSourceFeatureChain) { + public ConnectorAsUsageCheckerBuilder setExpectedSourceFeatureChain(List anExpectedSourceFeatureChain) { this.expectedSourceFeatureChain = anExpectedSourceFeatureChain; return this; } - public ConnectorAsUsageChecker setExpectedSourceReference(String anExpectedSourceReference) { + public ConnectorAsUsageCheckerBuilder setExpectedSourceReference(String anExpectedSourceReference) { this.expectedSourceReference = anExpectedSourceReference; return this; } - public ConnectorAsUsageChecker setExpectedSourceSemanticId(String anExpectedSourceSemanticId) { + public ConnectorAsUsageCheckerBuilder setExpectedSourceSemanticId(String anExpectedSourceSemanticId) { this.expectedSourceSemanticId = anExpectedSourceSemanticId; return this; } - public ConnectorAsUsageChecker setExpectedTargetSemanticId(String anExpectedTargetSemanticId) { + public ConnectorAsUsageCheckerBuilder setExpectedTargetSemanticId(String anExpectedTargetSemanticId) { this.expectedTargetSemanticId = anExpectedTargetSemanticId; return this; } - public ConnectorAsUsageChecker setExpectedTargetFeatureChain(List anExpectedTargetFeatureChain) { + public ConnectorAsUsageCheckerBuilder setExpectedTargetFeatureChain(List anExpectedTargetFeatureChain) { this.expectedTargetFeatureChain = anExpectedTargetFeatureChain; return this; } - public ConnectorAsUsageChecker setExpectedTargetReference(String anExpectedTargetReference) { + public ConnectorAsUsageCheckerBuilder setExpectedTargetReference(String anExpectedTargetReference) { this.expectedTargetReference = anExpectedTargetReference; return this; } - public void run(Step verifier, AtomicReference edgeIdProvider) { - - this.semanticCheckerService.checkElement(verifier, this.expectedType, edgeIdProvider::get, + public Runnable build(AtomicReference edgeIdProvider) { + return this.semanticCheckerService.checkElement(this.expectedType, edgeIdProvider::get, connectorAsUsage -> { assertThat(this.identityService.getId(connectorAsUsage.getSourceFeature().getFeatureTarget())) .isEqualTo(this.expectedSourceSemanticId); @@ -113,9 +109,9 @@ public void run(Step } else if (this.expectedSourceFeatureChain != null) { assertThat(connectorAsUsage.getSourceFeature().getOwnedFeatureChaining().stream() .map(FeatureChaining::getChainingFeature) - .map(fc -> this.identityService.getId(fc)) + .map(this.identityService::getId) .toList()) - .isEqualTo(this.expectedSourceFeatureChain); + .isEqualTo(this.expectedSourceFeatureChain); } if (this.expectedTargetReference != null) { assertThat(this.identityService.getId(connectorAsUsage.getTargetFeature().get(0))) @@ -123,9 +119,9 @@ public void run(Step } else if (this.expectedTargetFeatureChain != null) { assertThat(connectorAsUsage.getTargetFeature().get(0).getOwnedFeatureChaining().stream() .map(FeatureChaining::getChainingFeature) - .map(fc -> this.identityService.getId(fc)) + .map(this.identityService::getId) .toList()) - .isEqualTo(this.expectedTargetFeatureChain); + .isEqualTo(this.expectedTargetFeatureChain); } }); } diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVBindingConnectorAsUsageTests.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVBindingConnectorAsUsageTests.java index f354f9dcf..4bd9e4f6c 100644 --- a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVBindingConnectorAsUsageTests.java +++ b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVBindingConnectorAsUsageTests.java @@ -13,6 +13,7 @@ package org.eclipse.syson.application.controllers.diagrams.general.view; import static org.assertj.core.api.Assertions.assertThat; +import static org.eclipse.sirius.components.diagrams.tests.DiagramEventPayloadConsumer.assertRefreshedDiagramThat; import static org.eclipse.sirius.components.diagrams.tests.assertions.DiagramAssertions.assertThat; import static org.eclipse.sirius.components.diagrams.tests.assertions.DiagramInstanceOfAssertFactories.EDGE; import static org.eclipse.sirius.components.diagrams.tests.assertions.DiagramInstanceOfAssertFactories.EDGE_STYLE; @@ -21,6 +22,7 @@ import java.util.List; import java.util.UUID; import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; import org.eclipse.sirius.components.collaborative.diagrams.dto.DiagramEventInput; import org.eclipse.sirius.components.collaborative.diagrams.dto.DiagramRefreshedEventPayload; @@ -33,12 +35,11 @@ import org.eclipse.sirius.components.view.emf.diagram.IDiagramIdProvider; import org.eclipse.sirius.web.tests.services.api.IGivenInitialServerState; import org.eclipse.syson.AbstractIntegrationTests; +import org.eclipse.syson.GivenSysONServer; import org.eclipse.syson.SysONTestsProperties; import org.eclipse.syson.application.controller.editingContext.checkers.SemanticCheckerService; import org.eclipse.syson.application.controllers.diagrams.checkers.CheckDiagramElementCount; -import org.eclipse.syson.application.controllers.diagrams.checkers.ConnectorAsUsageChecker; -import org.eclipse.syson.application.controllers.diagrams.checkers.DiagramCheckerService; -import org.eclipse.syson.application.controllers.diagrams.checkers.IDiagramChecker; +import org.eclipse.syson.application.controllers.diagrams.checkers.ConnectorAsUsageCheckerBuilder; import org.eclipse.syson.application.controllers.diagrams.testers.EdgeCreationTester; import org.eclipse.syson.application.controllers.diagrams.testers.EdgeReconnectionTester; import org.eclipse.syson.application.data.GeneralViewBindingConnectorProjectData; @@ -46,23 +47,20 @@ import org.eclipse.syson.services.diagrams.DiagramComparator; import org.eclipse.syson.services.diagrams.DiagramDescriptionIdProvider; import org.eclipse.syson.services.diagrams.api.IGivenDiagramDescription; -import org.eclipse.syson.services.diagrams.api.IGivenDiagramReference; import org.eclipse.syson.services.diagrams.api.IGivenDiagramSubscription; import org.eclipse.syson.standard.diagrams.view.SDVDescriptionNameGenerator; import org.eclipse.syson.sysml.BindingConnectorAsUsage; import org.eclipse.syson.sysml.SysmlPackage; import org.eclipse.syson.util.IDescriptionNameGenerator; import org.eclipse.syson.util.SysONRepresentationDescriptionIdentifiers; -import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlConfig; import org.springframework.transaction.annotation.Transactional; +import reactor.core.publisher.Flux; import reactor.test.StepVerifier; /** @@ -79,9 +77,6 @@ public class GVBindingConnectorAsUsageTests extends AbstractIntegrationTests { @Autowired private IGivenInitialServerState givenInitialServerState; - @Autowired - private IGivenDiagramReference givenDiagram; - @Autowired private IGivenDiagramDescription givenDiagramDescription; @@ -109,141 +104,204 @@ public class GVBindingConnectorAsUsageTests extends AbstractIntegrationTests { @Autowired private EdgeReconnectionTester edgeReconnectionTester; - private DiagramDescriptionIdProvider diagramDescriptionIdProvider; - - private DiagramCheckerService diagramCheckerService; - - private StepVerifier.Step verifier; - private SemanticCheckerService semanticCheckerService; - private AtomicReference diagram; + private Flux givenSubscriptionToDiagram() { + var diagramEventInput = new DiagramEventInput(UUID.randomUUID(), GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.DIAGRAM_ID); + return this.givenDiagramSubscription.subscribe(diagramEventInput); + } @BeforeEach public void setUp() { this.givenInitialServerState.initialize(); - var diagramEventInput = new DiagramEventInput(UUID.randomUUID(), - GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, - GeneralViewBindingConnectorProjectData.GraphicalIds.DIAGRAM_ID); - var flux = this.givenDiagramSubscription.subscribe(diagramEventInput); - this.verifier = StepVerifier.create(flux); - this.diagram = this.givenDiagram.getDiagram(this.verifier); - var diagramDescription = this.givenDiagramDescription.getDiagramDescription(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, - SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); - this.diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); - this.diagramCheckerService = new DiagramCheckerService(this.diagramComparator, this.descriptionNameGenerator); this.semanticCheckerService = new SemanticCheckerService(this.semanticRunnableFactory, this.objectSearchService, GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, GeneralViewBindingConnectorProjectData.SemanticIds.PACKAGE_1_ID); } - @AfterEach - public void tearDown() { - if (this.verifier != null) { - this.verifier.thenCancel() - .verify(Duration.ofSeconds(10)); - } - } - @DisplayName("GIVEN a ActionUsage with nested item (1 level), WHEN creating a BindingConnectorAsUsage, THEN the binding should be created in the common container (A0) and a feature chain should be created for non direct features in target") - @Sql(scripts = { GeneralViewBindingConnectorProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ GeneralViewBindingConnectorProjectData.SCRIPT_PATH }) @Test public void bindingNestedLevel1() { + var flux = this.givenSubscriptionToDiagram(); - AtomicReference newEdge = this.createEdge(GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, - GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID); + AtomicReference newEdge = new AtomicReference<>(); + Consumer edgeChecker = this.assertNewEdgeThat(GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, + GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, diagram, newEdge::set); + // I0 -> I1 - this.createChecker() + Runnable semanticChecker = this.createCheckerBuilder() .setExpectedSourceSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I0_ID) .setExpectedTargetSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I1_ID) .setExpectedSemanticContainer(GeneralViewBindingConnectorProjectData.SemanticIds.A0_ID) .setExpectedSourceReference(GeneralViewBindingConnectorProjectData.SemanticIds.I0_ID) .setExpectedTargetFeatureChain(List.of(GeneralViewBindingConnectorProjectData.SemanticIds.A1_ID, GeneralViewBindingConnectorProjectData.SemanticIds.I1_ID)) - .run(this.verifier, newEdge); - + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(edgeChecker) + .then(semanticChecker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("GIVEN a ActionUsage with nested item (1 level), WHEN creating a BindingConnectorAsUsage, THEN the binding should be created in the common container (A0) and a feature chain should be created for non direct features in source") - @Sql(scripts = { GeneralViewBindingConnectorProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ GeneralViewBindingConnectorProjectData.SCRIPT_PATH }) @Test public void bindingNestedLevel1Reversed() { + var flux = this.givenSubscriptionToDiagram(); - AtomicReference newEdge = this.createEdge(GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, - GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, + AtomicReference diagram = new AtomicReference<>(); + Consumer diagramChecker = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID); + AtomicReference newEdge = new AtomicReference<>(); + Consumer edgeChecker = this.assertNewEdgeThat(GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, + GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, diagram, newEdge::set); + // I1 -> I0 - this.createChecker() + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I1_ID) .setExpectedTargetSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I0_ID) .setExpectedSemanticContainer(GeneralViewBindingConnectorProjectData.SemanticIds.A0_ID) .setExpectedTargetReference(GeneralViewBindingConnectorProjectData.SemanticIds.I0_ID) .setExpectedSourceFeatureChain(List.of(GeneralViewBindingConnectorProjectData.SemanticIds.A1_ID, GeneralViewBindingConnectorProjectData.SemanticIds.I1_ID)) - .run(this.verifier, newEdge); - + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(diagramChecker) + .then(createEdgeRunnable) + .consumeNextWith(edgeChecker) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("GIVEN a ActionUsage with nested item (2 level), WHEN creating a BindingConnectorAsUsage, THEN the binding should be created in the common container (A0) and a feature chain should be created for non direct features in source") - @Sql(scripts = { GeneralViewBindingConnectorProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ GeneralViewBindingConnectorProjectData.SCRIPT_PATH }) @Test public void bindingNestedLevel2() { + var flux = this.givenSubscriptionToDiagram(); - AtomicReference newEdge = this.createEdge(GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, - GeneralViewBindingConnectorProjectData.GraphicalIds.I11_ID, + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I11_ID); + + AtomicReference newEdge = new AtomicReference<>(); + Consumer edgeChecker = this.assertNewEdgeThat(GeneralViewBindingConnectorProjectData.GraphicalIds.I0_ID, + GeneralViewBindingConnectorProjectData.GraphicalIds.I11_ID, diagram, newEdge::set); + // I0 -> I11 - this.createChecker() + Runnable semanticChecker = this.createCheckerBuilder() .setExpectedSourceSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I0_ID) .setExpectedTargetSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I11_ID) .setExpectedSemanticContainer(GeneralViewBindingConnectorProjectData.SemanticIds.A0_ID) .setExpectedSourceReference(GeneralViewBindingConnectorProjectData.SemanticIds.I0_ID) .setExpectedTargetFeatureChain(List.of(GeneralViewBindingConnectorProjectData.SemanticIds.A1_ID, GeneralViewBindingConnectorProjectData.SemanticIds.A11_ID, GeneralViewBindingConnectorProjectData.SemanticIds.I11_ID)) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(edgeChecker) + .then(semanticChecker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("GIVEN a ActionUsage owning sibling items, WHEN creating a BindingConnectorAsUsage, THEN the binding should be created the common container (A11) and feature should be directly referenced") - @Sql(scripts = { GeneralViewBindingConnectorProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ GeneralViewBindingConnectorProjectData.SCRIPT_PATH }) @Test public void bindingSameLevel() { + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); - AtomicReference newEdge = this.createEdge(GeneralViewBindingConnectorProjectData.GraphicalIds.I11_ID, - GeneralViewBindingConnectorProjectData.GraphicalIds.I11TEST_ID, + Runnable createEdgeRunnable = buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, GeneralViewBindingConnectorProjectData.GraphicalIds.I11_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I11TEST_ID); + AtomicReference newEdge = new AtomicReference<>(); + Consumer edgeChecker = this.assertNewEdgeThat(GeneralViewBindingConnectorProjectData.GraphicalIds.I11_ID, + GeneralViewBindingConnectorProjectData.GraphicalIds.I11TEST_ID, diagram, newEdge::set); + // I11 -> I11Test - this.createChecker() + Runnable semanticChecker = this.createCheckerBuilder() .setExpectedSourceSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I11_ID) .setExpectedTargetSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I11TEST_ID) .setExpectedSemanticContainer(GeneralViewBindingConnectorProjectData.SemanticIds.A11_ID) .setExpectedSourceReference(GeneralViewBindingConnectorProjectData.SemanticIds.I11_ID) .setExpectedTargetReference(GeneralViewBindingConnectorProjectData.SemanticIds.I11TEST_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(edgeChecker) + .then(semanticChecker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("GIVEN a ActionUsage with existing binding, WHEN reconnecting target, THEN binding should be moved to new the common container (A1) and the source/target should be recomputed") - @Sql(scripts = { GeneralViewBindingConnectorProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ GeneralViewBindingConnectorProjectData.SCRIPT_PATH }) @Test public void reconnectTargetSameLevel() { + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + Runnable edgeReconnectionChecker = () -> this.edgeReconnectionTester.reconnectEdge(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, + diagram, + GeneralViewBindingConnectorProjectData.GraphicalIds.BINDING_EDGE_ID, + GeneralViewBindingConnectorProjectData.GraphicalIds.I2_ID, + ReconnectEdgeKind.TARGET); - var newEdge = this.reconnect(GeneralViewBindingConnectorProjectData.GraphicalIds.BINDING_EDGE_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I2_ID, ReconnectEdgeKind.TARGET, - GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I2_ID); - this.createChecker() + AtomicReference newEdge = new AtomicReference<>(); + var reconnectConsumer = this.assertReconnectThat(GeneralViewBindingConnectorProjectData.GraphicalIds.I1_ID, GeneralViewBindingConnectorProjectData.GraphicalIds.I2_ID, diagram, newEdge::set); + + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I1_ID) .setExpectedTargetSemanticId(GeneralViewBindingConnectorProjectData.SemanticIds.I2_ID) // Semantic container should change from A0 to A1 @@ -251,29 +309,29 @@ public void reconnectTargetSameLevel() { .setExpectedSourceReference(GeneralViewBindingConnectorProjectData.SemanticIds.I1_ID) // No more feature chain required .setExpectedTargetReference(GeneralViewBindingConnectorProjectData.SemanticIds.I2_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(edgeReconnectionChecker) + .consumeNextWith(reconnectConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } - private ConnectorAsUsageChecker createChecker() { - return new ConnectorAsUsageChecker<>(this.identityService, this.semanticCheckerService, BindingConnectorAsUsage.class); + private ConnectorAsUsageCheckerBuilder createCheckerBuilder() { + return new ConnectorAsUsageCheckerBuilder<>(this.identityService, BindingConnectorAsUsage.class, this.semanticCheckerService); } - private AtomicReference reconnect(String edgeId, String newTarget, ReconnectEdgeKind reconnectionKind, String expectedSourceGraplicalId, String expectedTargetGraplicalId) { - - this.verifier.then(() -> this.edgeReconnectionTester.reconnectEdge(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, - this.diagram, - edgeId, - newTarget, - reconnectionKind)); - - var result = new AtomicReference(); - IDiagramChecker diagramCheckerTarget = (initialDiagram, newDiagram) -> { + private Consumer assertReconnectThat(String expectedSourceGraplicalId, String expectedTargetGraplicalId, AtomicReference diagram, Consumer newEdgeConsumer) { + return assertRefreshedDiagramThat(newDiagram -> { new CheckDiagramElementCount(this.diagramComparator) .hasNewEdgeCount(1) - .check(initialDiagram, newDiagram); + .check(diagram.get(), newDiagram); - Edge newEdge = this.diagramComparator.newEdges(initialDiagram, newDiagram).get(0); - result.set(newEdge.getTargetObjectId()); + Edge newEdge = this.diagramComparator.newEdges(diagram.get(), newDiagram).get(0); + newEdgeConsumer.accept(newEdge.getTargetObjectId()); assertThat(newEdge) .hasSourceId(expectedSourceGraplicalId) .hasTargetId(expectedTargetGraplicalId) @@ -282,31 +340,27 @@ private AtomicReference reconnect(String edgeId, String newTarget, Recon .hasTargetArrow(ArrowStyle.None); assertThat(newEdge) .extracting(e -> e.getCenterLabel().text()).isEqualTo("="); - }; - - this.diagramCheckerService.checkDiagram(diagramCheckerTarget, this.diagram, this.verifier); - - return result; + }); } - private AtomicReference createEdge(String sourceNodeId, String targetNodeId, String expectedSourceGraphicalId, String expectedTargetGraphicalId) { - String creationToolId = this.diagramDescriptionIdProvider.getEdgeCreationToolId( + private Runnable buildCreateEdgeRunnable(DiagramDescriptionIdProvider diagramDescriptionIdProvider, AtomicReference diagram, String sourceNodeId, String targetNodeId) { + String creationToolId = diagramDescriptionIdProvider.getEdgeCreationToolId( this.descriptionNameGenerator.getBorderNodeName(SysmlPackage.eINSTANCE.getItemUsage(), SysmlPackage.eINSTANCE.getBehavior_Parameter()), "New Binding Connector As Usage (bind)"); - this.verifier.then(() -> this.edgeCreationTester.createEdgeUsingNodeId(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, - this.diagram, + return () -> this.edgeCreationTester.createEdgeUsingNodeId(GeneralViewBindingConnectorProjectData.EDITING_CONTEXT_ID, + diagram, sourceNodeId, targetNodeId, - creationToolId)); - - var result = new AtomicReference(); + creationToolId); + } - IDiagramChecker diagramChecker = (initialDiagram, newDiagram) -> { + private Consumer assertNewEdgeThat(String expectedSourceGraphicalId, String expectedTargetGraphicalId, AtomicReference diagram, Consumer newEdgeConsumer) { + return assertRefreshedDiagramThat(newDiagram -> { new CheckDiagramElementCount(this.diagramComparator) .hasNewNodeCount(0) .hasNewEdgeCount(1) - .check(initialDiagram, newDiagram); - List newEdges = this.diagramComparator.newEdges(initialDiagram, newDiagram); + .check(diagram.get(), newDiagram); + List newEdges = this.diagramComparator.newEdges(diagram.get(), newDiagram); assertThat(newEdges).hasSize(1).first(EDGE) .hasSourceId(expectedSourceGraphicalId) .hasTargetId(expectedTargetGraphicalId) @@ -315,11 +369,8 @@ private AtomicReference createEdge(String sourceNodeId, String targetNod .hasTargetArrow(ArrowStyle.None); assertThat(newEdges).hasSize(1).first(EDGE) .extracting(e -> e.getCenterLabel().text()).isEqualTo("="); - result.set(newEdges.get(0).getTargetObjectId()); - }; - - this.diagramCheckerService.checkDiagram(diagramChecker, this.diagram, this.verifier); - return result; + newEdgeConsumer.accept(newEdges.get(0).getTargetObjectId()); + }); } } diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVConnectionUsageEdgeTests.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVConnectionUsageEdgeTests.java index eefaeba2f..4c3e2631a 100644 --- a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVConnectionUsageEdgeTests.java +++ b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/general/view/GVConnectionUsageEdgeTests.java @@ -13,6 +13,7 @@ package org.eclipse.syson.application.controllers.diagrams.general.view; import static org.assertj.core.api.Assertions.assertThat; +import static org.eclipse.sirius.components.diagrams.tests.DiagramEventPayloadConsumer.assertRefreshedDiagramThat; import static org.eclipse.sirius.components.diagrams.tests.assertions.DiagramInstanceOfAssertFactories.EDGE; import static org.eclipse.sirius.components.diagrams.tests.assertions.DiagramInstanceOfAssertFactories.EDGE_STYLE; @@ -20,6 +21,7 @@ import java.util.List; import java.util.UUID; import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; import org.eclipse.sirius.components.collaborative.diagrams.dto.DiagramEventInput; import org.eclipse.sirius.components.collaborative.diagrams.dto.DiagramRefreshedEventPayload; @@ -28,19 +30,19 @@ import org.eclipse.sirius.components.diagrams.ArrowStyle; import org.eclipse.sirius.components.diagrams.Diagram; import org.eclipse.sirius.components.diagrams.Edge; +import org.eclipse.sirius.components.diagrams.Label; import org.eclipse.sirius.components.diagrams.ViewModifier; import org.eclipse.sirius.components.diagrams.events.ReconnectEdgeKind; import org.eclipse.sirius.components.diagrams.tests.assertions.DiagramAssertions; import org.eclipse.sirius.components.diagrams.tests.graphql.EditLabelMutationRunner; -import org.eclipse.sirius.components.view.diagram.DiagramDescription; +import org.eclipse.sirius.components.diagrams.tests.navigation.DiagramNavigator; import org.eclipse.sirius.components.view.emf.diagram.IDiagramIdProvider; import org.eclipse.sirius.web.tests.services.api.IGivenInitialServerState; import org.eclipse.syson.AbstractIntegrationTests; +import org.eclipse.syson.GivenSysONServer; import org.eclipse.syson.application.controller.editingContext.checkers.SemanticCheckerService; import org.eclipse.syson.application.controllers.diagrams.checkers.CheckDiagramElementCount; -import org.eclipse.syson.application.controllers.diagrams.checkers.ConnectorAsUsageChecker; -import org.eclipse.syson.application.controllers.diagrams.checkers.DiagramCheckerService; -import org.eclipse.syson.application.controllers.diagrams.checkers.IDiagramChecker; +import org.eclipse.syson.application.controllers.diagrams.checkers.ConnectorAsUsageCheckerBuilder; import org.eclipse.syson.application.controllers.diagrams.testers.DirectEditTester; import org.eclipse.syson.application.controllers.diagrams.testers.EdgeCreationTester; import org.eclipse.syson.application.controllers.diagrams.testers.EdgeReconnectionTester; @@ -49,23 +51,20 @@ import org.eclipse.syson.services.diagrams.DiagramComparator; import org.eclipse.syson.services.diagrams.DiagramDescriptionIdProvider; import org.eclipse.syson.services.diagrams.api.IGivenDiagramDescription; -import org.eclipse.syson.services.diagrams.api.IGivenDiagramReference; import org.eclipse.syson.services.diagrams.api.IGivenDiagramSubscription; import org.eclipse.syson.standard.diagrams.view.SDVDescriptionNameGenerator; import org.eclipse.syson.sysml.ConnectionUsage; import org.eclipse.syson.sysml.SysmlPackage; import org.eclipse.syson.util.IDescriptionNameGenerator; import org.eclipse.syson.util.SysONRepresentationDescriptionIdentifiers; -import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlConfig; import org.springframework.transaction.annotation.Transactional; +import reactor.core.publisher.Flux; import reactor.test.StepVerifier; /** @@ -82,9 +81,6 @@ public class GVConnectionUsageEdgeTests extends AbstractIntegrationTests { @Autowired private IGivenInitialServerState givenInitialServerState; - @Autowired - private IGivenDiagramReference givenDiagram; - @Autowired private IGivenDiagramDescription givenDiagramDescription; @@ -115,279 +111,463 @@ public class GVConnectionUsageEdgeTests extends AbstractIntegrationTests { @Autowired private EditLabelMutationRunner editLabelMutationRunner; - private DiagramDescriptionIdProvider diagramDescriptionIdProvider; - - private StepVerifier.Step verifier; - - private AtomicReference diagram; + private DirectEditTester directEditTester; private final IDescriptionNameGenerator descriptionNameGenerator = new SDVDescriptionNameGenerator(); - private DiagramCheckerService diagramCheckerService; - private SemanticCheckerService semanticCheckerService; - private DirectEditTester directEditTester; + private Flux givenSubscriptionToDiagram() { + var diagramEventInput = new DiagramEventInput(UUID.randomUUID(), EDITING_CONTEXT_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.DIAGRAM_ID); + return this.givenDiagramSubscription.subscribe(diagramEventInput); + } @BeforeEach public void setUp() { this.givenInitialServerState.initialize(); - var diagramEventInput = new DiagramEventInput(UUID.randomUUID(), - EDITING_CONTEXT_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.DIAGRAM_ID); - var flux = this.givenDiagramSubscription.subscribe(diagramEventInput); - this.verifier = StepVerifier.create(flux); - this.diagram = this.givenDiagram.getDiagram(this.verifier); - DiagramDescription diagramDescription = this.givenDiagramDescription.getDiagramDescription(EDITING_CONTEXT_ID, - SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); - this.diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); - this.diagramCheckerService = new DiagramCheckerService(this.diagramComparator, this.descriptionNameGenerator); this.semanticCheckerService = new SemanticCheckerService(this.semanticRunnableFactory, this.objectSearchService, EDITING_CONTEXT_ID, EdgeConnectionUsageTestProjectData.SemanticIds.PACKAGE1_ID); this.directEditTester = new DirectEditTester(this.editLabelMutationRunner, EdgeConnectionUsageTestProjectData.EDITING_CONTEXT_ID); - - } - - @AfterEach - public void tearDown() { - if (this.verifier != null) { - this.verifier.thenCancel() - .verify(Duration.ofSeconds(10)); - } } @DisplayName("Given two PartUsages in a package, WHEN using an Edge tool to create a ConnectionUsage in between, THEN a ConnectionUsage edge is created") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void createConnectionUsageOnParts() { - AtomicReference newEdge = this.createEdge( + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = this.buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, this.descriptionNameGenerator.getNodeName(SysmlPackage.eINSTANCE.getPartUsage()), EdgeConnectionUsageTestProjectData.GraphicalIds.PART1_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.PART2_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.PART2_ID); + + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertNewEdgeThat( EdgeConnectionUsageTestProjectData.GraphicalIds.PART1_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.PART2_ID, - "connection1"); + "connection1", + diagram, + newEdge::set); - this.createChecker() + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PART1_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PART2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.PACKAGE1_ID) .setExpectedSourceReference(EdgeConnectionUsageTestProjectData.SemanticIds.PART1_ID) .setExpectedTargetReference(EdgeConnectionUsageTestProjectData.SemanticIds.PART2_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given two PartUsages contained in a common context, WHEN using an Edge tool to create a ConnectionUsage in between, THEN a ConnectionUsage edge is created") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void createConnectionUsageOnPartsWithCommonContext() { - AtomicReference newEdge = this.createEdge( + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = this.buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, this.descriptionNameGenerator.getNodeName(SysmlPackage.eINSTANCE.getPartUsage()), EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART1_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID); + + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertNewEdgeThat( EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART1_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID, - "connection2"); + "connection2", + diagram, + newEdge::set); - this.createChecker() + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ID) .setExpectedSourceReference(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID) .setExpectedTargetReference(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given two ItemUsage contained in a common context PartUsage, WHEN using an Edge tool to create a ConnectionUsage in between, THEN a ConnectionUsage edge is created with valid " + "feature chain") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void createConnectionUsageOnItemUsageWithCommonContext() { - AtomicReference newEdge = this.createEdge( + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = this.buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, this.descriptionNameGenerator.getNodeName(SysmlPackage.eINSTANCE.getItemUsage()), EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM1_IN_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID); + + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertNewEdgeThat( EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM1_IN_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID, - "connection2"); + "connection2", + diagram, + newEdge::set); - this.createChecker() + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM1IN_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ID) .setExpectedSourceFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID, EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM1IN_ID)) .setExpectedTargetFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID, EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM2_ID)) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given two PortUsage contained in a common context PartUsage, WHEN using an Edge tool to create a ConnectionUsage in between, THEN a ConnectionUsage edge is created with valid " + "feature chain") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void createConnectionUsageOnPortUsageUsageWithCommonContext() { - AtomicReference newEdge = this.createEdge( + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = this.buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, this.descriptionNameGenerator.getBorderNodeName(SysmlPackage.eINSTANCE.getPortUsage(), SysmlPackage.eINSTANCE.getUsage_NestedPort()), EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PORT11_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PORT22_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PORT22_ID); + + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertNewEdgeThat( EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PORT11_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PORT22_ID, - "connection2"); + "connection2", + diagram, + newEdge::set); - this.createChecker() + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PORT11_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PORT22_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ID) .setExpectedSourceFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID, EdgeConnectionUsageTestProjectData.SemanticIds.PORT11_ID)) .setExpectedTargetFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID, EdgeConnectionUsageTestProjectData.SemanticIds.PORT22_ID)) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given two inherited PortUsage contained in a common context PartUsage, WHEN using an Edge tool to create a ConnectionUsage in between, THEN a ConnectionUsage edge is created with " + "valid " + "feature chain") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void createConnectionUsageOnInheritedPortUsageUsageWithCommonContext() { - AtomicReference newEdge = this.createEdge( + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + var diagramDescription = this.givenDiagramDescription.getDiagramDescription(EDITING_CONTEXT_ID, + SysONRepresentationDescriptionIdentifiers.GENERAL_VIEW_DIAGRAM_DESCRIPTION_ID); + var diagramDescriptionIdProvider = new DiagramDescriptionIdProvider(diagramDescription, this.diagramIdProvider); + + Runnable createEdgeRunnable = this.buildCreateEdgeRunnable( + diagramDescriptionIdProvider, + diagram, this.descriptionNameGenerator.getInheritedBorderNodeName(SysmlPackage.eINSTANCE.getPortUsage(), SysmlPackage.eINSTANCE.getUsage_NestedPort()), EdgeConnectionUsageTestProjectData.GraphicalIds.INHERITED_PD1_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.INHERITED_PD2_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.INHERITED_PD2_ID); + + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertNewEdgeThat( EdgeConnectionUsageTestProjectData.GraphicalIds.INHERITED_PD1_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.INHERITED_PD2_ID, - "connection2"); + "connection2", + diagram, + newEdge::set); - this.createChecker() + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PD1_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PD2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ID) .setExpectedSourceFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID, EdgeConnectionUsageTestProjectData.SemanticIds.PD1_ID)) .setExpectedTargetFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID, EdgeConnectionUsageTestProjectData.SemanticIds.PD2_ID)) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given a ConnectionUsage, WHEN reconnecting the source to a new source within the same context , THEN a ConnectionUsage updated but the container is not changed") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void reconnectSourceSameContext() { - var newEdge = this.reconnect(EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART1_ID, ReconnectEdgeKind.SOURCE, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART1_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID); + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + Runnable createEdgeRunnable = this.buildReconnectRunnable( + EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART1_ID, + ReconnectEdgeKind.SOURCE, + diagram); - this.createChecker() + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertReconnectThat( + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART1_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID, + diagram, + newEdge::set); + + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ID) .setExpectedSourceReference(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID) .setExpectedTargetFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID, EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM2_ID)) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given a ConnectionUsage, WHEN reconnecting the source to a new source within a new context, THEN a ConnectionUsage updated and the container is changed") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void reconnectSourceChangeContext() { - var newEdge = this.reconnect(EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.PORT1_ID, ReconnectEdgeKind.SOURCE, - EdgeConnectionUsageTestProjectData.GraphicalIds.PORT1_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID); + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + Runnable createEdgeRunnable = this.buildReconnectRunnable( + EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.PORT1_ID, + ReconnectEdgeKind.SOURCE, + diagram); - this.createChecker() + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertReconnectThat( + EdgeConnectionUsageTestProjectData.GraphicalIds.PORT1_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM2_OUT_ID, + diagram, + newEdge::set); + + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PORT1_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.PACKAGE1_ID) .setExpectedSourceReference(EdgeConnectionUsageTestProjectData.SemanticIds.PORT1_ID) .setExpectedTargetReference(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM2_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given a ConnectionUsage, WHEN reconnecting the target to a new target within the same context, THEN a ConnectionUsage is updated but the container is not changed") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void reconnectTargetSameContext() { - var newEdge = this.reconnect(EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID, ReconnectEdgeKind.TARGET, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM1_IN_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID); + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + Runnable createEdgeRunnable = this.buildReconnectRunnable( + EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID, + ReconnectEdgeKind.TARGET, + diagram); - this.createChecker() + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertReconnectThat( + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM1_IN_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_PART2_ID, + diagram, + newEdge::set); + + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM1IN_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ID) .setExpectedSourceFeatureChain(List.of(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART1_ID, EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM1IN_ID)) .setExpectedTargetReference(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_PART2_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given a ConnectionUsage, WHEN reconnecting the target to a new target in a new context , THEN a ConnectionUsage is updated and the container is changed") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void reconnectTargetChangeContext() { - var newEdge = this.reconnect(EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, - EdgeConnectionUsageTestProjectData.GraphicalIds.PORT2_ID, ReconnectEdgeKind.TARGET, - EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM1_IN_ID, EdgeConnectionUsageTestProjectData.GraphicalIds.PORT2_ID); + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + Runnable createEdgeRunnable = this.buildReconnectRunnable( + EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.PORT2_ID, + ReconnectEdgeKind.TARGET, + diagram); - this.createChecker() + AtomicReference newEdge = new AtomicReference<>(); + Consumer newEdgeConsumer = this.assertReconnectThat( + EdgeConnectionUsageTestProjectData.GraphicalIds.SYSTEM_ITEM1_IN_ID, + EdgeConnectionUsageTestProjectData.GraphicalIds.PORT2_ID, + diagram, + newEdge::set); + + Runnable checker = this.createCheckerBuilder() .setExpectedSourceSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM1IN_ID) .setExpectedTargetSemanticId(EdgeConnectionUsageTestProjectData.SemanticIds.PORT2_ID) .setExpectedSemanticContainer(EdgeConnectionUsageTestProjectData.SemanticIds.PACKAGE1_ID) .setExpectedSourceReference(EdgeConnectionUsageTestProjectData.SemanticIds.SYSTEM_ITEM1IN_ID) .setExpectedTargetReference(EdgeConnectionUsageTestProjectData.SemanticIds.PORT2_ID) - .run(this.verifier, newEdge); + .build(newEdge); + + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(createEdgeRunnable) + .consumeNextWith(newEdgeConsumer) + .then(checker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } @DisplayName("Given a ConnectionUsage, WHEN direct editing its centered label, THEN type of the usage is set") @Test - @Sql(scripts = { EdgeConnectionUsageTestProjectData.SCRIPT_PATH }, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, - config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) - @Sql(scripts = { "/scripts/cleanup.sql" }, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD, config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED)) + @GivenSysONServer({ EdgeConnectionUsageTestProjectData.SCRIPT_PATH }) public void directEditFeatureTyping() { - this.directEditTester.checkDirectEditCenteredEdgeLabel(this.verifier, this.diagram, EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, "connection0 : ConnectionDefinition1", "connection0 : ConnectionDefinition1"); + var flux = this.givenSubscriptionToDiagram(); + + AtomicReference diagram = new AtomicReference<>(); + Consumer initialDiagramContentConsumer = assertRefreshedDiagramThat(diagram::set); + + Runnable requestDirectEdit = this.directEditTester.directEditCenteredEdgeLabel(diagram, + EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID, + "connection0 : ConnectionDefinition1"); + + Consumer diagramConsumer = assertRefreshedDiagramThat(newDiagram -> { + DiagramNavigator diagramNavigator = new DiagramNavigator(newDiagram); - this.semanticCheckerService.checkElement(this.verifier, ConnectionUsage.class, () -> EdgeConnectionUsageTestProjectData.SemanticIds.CONNECTION_0_ID, connectionUsage -> { + Label newLabel = diagramNavigator.edgeWithId(EdgeConnectionUsageTestProjectData.GraphicalIds.CONNECTION_0_ID).getEdge().getCenterLabel(); + assertThat(newLabel.text()).isEqualTo("connection0 : ConnectionDefinition1"); + }); + + Runnable runnableChecker = this.semanticCheckerService.checkElement(ConnectionUsage.class, () -> EdgeConnectionUsageTestProjectData.SemanticIds.CONNECTION_0_ID, connectionUsage -> { assertThat(connectionUsage.getType()).hasSize(2) .allMatch(type -> "ConnectionDefinition1".equals(type.getName()) || "BinaryLinkObject".equals(type.getName())); }); + StepVerifier.create(flux) + .consumeNextWith(initialDiagramContentConsumer) + .then(requestDirectEdit) + .consumeNextWith(diagramConsumer) + .then(runnableChecker) + .thenCancel() + .verify(Duration.ofSeconds(10)); } - private AtomicReference createEdge(String sourceNodeDescriptionName, String sourceNodeId, String targetNodeId, String expectedSourceGraphicalId, String expectedTargetGraphicalId, - String expectedLabel) { - String creationToolId = this.diagramDescriptionIdProvider.getEdgeCreationToolId( + private Runnable buildCreateEdgeRunnable(DiagramDescriptionIdProvider diagramDescriptionIdProvider, AtomicReference diagram, String sourceNodeDescriptionName, String sourceNodeId, String targetNodeId) { + String creationToolId = diagramDescriptionIdProvider.getEdgeCreationToolId( sourceNodeDescriptionName, "New Connection"); - - - this.verifier.then(() -> this.edgeCreationTester.createEdgeUsingNodeId(EDITING_CONTEXT_ID, - this.diagram, + return () -> this.edgeCreationTester.createEdgeUsingNodeId(EDITING_CONTEXT_ID, + diagram, sourceNodeId, targetNodeId, - creationToolId)); - - var result = new AtomicReference(); + creationToolId); + } - IDiagramChecker diagramChecker = (initialDiagram, newDiagram) -> { + private Consumer assertNewEdgeThat(String expectedSourceGraphicalId, String expectedTargetGraphicalId, String expectedLabel, AtomicReference diagram, Consumer newEdgeConsumer) { + return assertRefreshedDiagramThat(newDiagram -> { new CheckDiagramElementCount(this.diagramComparator) .hasNewNodeCount(0) .hasNewEdgeCount(1) - .check(initialDiagram, newDiagram, true); - List newEdges = this.diagramComparator.newEdges(initialDiagram, newDiagram); + .check(diagram.get(), newDiagram, true); + List newEdges = this.diagramComparator.newEdges(diagram.get(), newDiagram); List newVisibleEdges = newEdges.stream().filter(edge -> edge.getState() != ViewModifier.Hidden).toList(); assertThat(newVisibleEdges).hasSize(1).first(EDGE) .hasSourceId(expectedSourceGraphicalId) @@ -397,44 +577,36 @@ private AtomicReference createEdge(String sourceNodeDescriptionName, Str .hasTargetArrow(ArrowStyle.None); assertThat(newVisibleEdges).hasSize(1).first(EDGE) .extracting(e -> e.getCenterLabel().text()).isEqualTo(expectedLabel); - result.set(newEdges.get(0).getTargetObjectId()); - }; - - this.diagramCheckerService.checkDiagram(diagramChecker, this.diagram, this.verifier); - return result; + newEdgeConsumer.accept(newEdges.get(0).getTargetObjectId()); + }); } - private ConnectorAsUsageChecker createChecker() { - return new ConnectorAsUsageChecker<>(this.identityService, this.semanticCheckerService, ConnectionUsage.class); + private ConnectorAsUsageCheckerBuilder createCheckerBuilder() { + return new ConnectorAsUsageCheckerBuilder<>(this.identityService, ConnectionUsage.class, this.semanticCheckerService); } - private AtomicReference reconnect(String edgeId, String newTarget, ReconnectEdgeKind reconnectionKind, String expectedSourceGraplicalId, String expectedTargetGraplicalId) { - - this.verifier.then(() -> this.edgeReconnectionTester.reconnectEdge(EDITING_CONTEXT_ID, - this.diagram, + private Runnable buildReconnectRunnable(String edgeId, String newTarget, ReconnectEdgeKind reconnectionKind, AtomicReference diagram) { + return () -> this.edgeReconnectionTester.reconnectEdge(EDITING_CONTEXT_ID, + diagram, edgeId, newTarget, - reconnectionKind)); + reconnectionKind); + } - var result = new AtomicReference(); - IDiagramChecker diagramCheckerTarget = (initialDiagram, newDiagram) -> { + private Consumer assertReconnectThat(String expectedSourceGraplicalId, String expectedTargetGraplicalId, AtomicReference diagram, Consumer newEdgeConsumer) { + return assertRefreshedDiagramThat(newDiagram -> { new CheckDiagramElementCount(this.diagramComparator) .hasNewEdgeCount(1) - .check(initialDiagram, newDiagram, true); + .check(diagram.get(), newDiagram, true); - Edge newEdge = this.diagramComparator.newEdges(initialDiagram, newDiagram).get(0); - result.set(newEdge.getTargetObjectId()); + Edge newEdge = this.diagramComparator.newEdges(diagram.get(), newDiagram).get(0); + newEdgeConsumer.accept(newEdge.getTargetObjectId()); DiagramAssertions.assertThat(newEdge) .hasSourceId(expectedSourceGraplicalId) .hasTargetId(expectedTargetGraplicalId) .extracting(Edge::getStyle, EDGE_STYLE) .hasSourceArrow(ArrowStyle.None) .hasTargetArrow(ArrowStyle.None); - }; - - this.diagramCheckerService.checkDiagram(diagramCheckerTarget, this.diagram, this.verifier); - - return result; + }); } - } diff --git a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/testers/DirectEditTester.java b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/testers/DirectEditTester.java index 3a640f9ba..e1b7e4b5f 100644 --- a/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/testers/DirectEditTester.java +++ b/backend/application/syson-application/src/test/java/org/eclipse/syson/application/controllers/diagrams/testers/DirectEditTester.java @@ -54,7 +54,7 @@ public DirectEditTester(EditLabelMutationRunner editLabelMutationRunner, String /** * Run a direct edit and check the resulting label for an {@link InsideLabel}. - * + * * @param verifier * the verifier * @param diagram @@ -65,7 +65,9 @@ public DirectEditTester(EditLabelMutationRunner editLabelMutationRunner, String * the input label to be used for the direct edit * @param expectedInsideLabel * the expected inside label + * @deprecated use {@link #directEditInsideLabel(AtomicReference, String, String)} instead. */ + @Deprecated public void checkDirectEditInsideLabel(Step verifier, AtomicReference diagram, String mainNodeId, String inputLabel, String expectedInsideLabel) { Consumer checker = payload -> Optional.of(payload) .map(DiagramRefreshedEventPayload::diagram) @@ -81,7 +83,7 @@ public void checkDirectEditInsideLabel(Step verifi /** * Run a direct edit and check the resulting label for an {@link OutsideLabel} (only check the first one available). - * + * * @param verifier * the verifier * @param diagram @@ -92,7 +94,9 @@ public void checkDirectEditInsideLabel(Step verifi * the input label to be used for the direct edit * @param expectedOutsideLabel * the expected outside label + * @deprecated use {@link #directEditOutsideLabel(AtomicReference, String, String)} instead. */ + @Deprecated public void checkDirectEditOutsideLabel(Step verifier, AtomicReference diagram, String mainNodeId, String inputLabel, String expectedOutsideLabel) { Consumer checker = payload -> Optional.of(payload) .map(DiagramRefreshedEventPayload::diagram) @@ -103,23 +107,25 @@ public void checkDirectEditOutsideLabel(Step verif assertThat(newLabel.text()).isEqualTo(expectedOutsideLabel); }, () -> fail("Missing diagram")); - this.checkDirectEdit(verifier, diagram, inputLabel, d -> this.getOutsideLabelid(mainNodeId, d), checker); + this.checkDirectEdit(verifier, diagram, inputLabel, d -> this.getOutsideLabelId(mainNodeId, d), checker); } /** * Runs a direct edit and checks the resulting label for an edge centered label. * * @param verifier - * the verifier + * the verifier * @param diagram - * the diagram + * the diagram * @param edgeId - * the id of the edge holding the centered label + * the id of the edge holding the centered label * @param inputLabel - * the input label to be used for the direct edit + * the input label to be used for the direct edit * @param expectedCenteredLabel - * the expected centered label + * the expected centered label + * @deprecated use {@link #directEditCenteredEdgeLabel(AtomicReference, String, String)} instead. */ + @Deprecated public void checkDirectEditCenteredEdgeLabel(Step verifier, AtomicReference diagram, String edgeId, String inputLabel, String expectedCenteredLabel) { Consumer checker = payload -> Optional.of(payload) @@ -135,7 +141,7 @@ public void checkDirectEditCenteredEdgeLabel(Step /** * Run a direct edit and check the resulting label for an {@link InsideLabel} (only check the first one available). - * + * * @param verifier * the verifier * @param diagram @@ -146,7 +152,9 @@ public void checkDirectEditCenteredEdgeLabel(Step * the input label to be used for the direct edit * @param checker * a check to be done after the diagram re-render + * @deprecated use {@link #directEditInsideLabel(AtomicReference, String, String)} instead. */ + @Deprecated public void checkDirectEditInsideLabel(Step verifier, AtomicReference diagram, String mainNodeId, String inputLabel, Consumer checker) { this.checkDirectEdit(verifier, diagram, inputLabel, d -> this.getInsideLabelId(mainNodeId, d), checker); @@ -154,7 +162,7 @@ public void checkDirectEditInsideLabel(Step verifi /** * Run a direct edit and check the resulting label for an {@link OutsideLabel} (only check the first one available). - * + * * @param verifier * the verifier * @param diagram @@ -165,12 +173,85 @@ public void checkDirectEditInsideLabel(Step verifi * the input label to be used for the direct edit * @param checker * a check to be done after the diagram re-render + * @deprecated use {@link #directEditOutsideLabel(AtomicReference, String, String)} instead. */ + @Deprecated public void checkDirectEditOutsideLabel(Step verifier, AtomicReference diagram, String mainNodeId, String inputLabel, Consumer checker) { - this.checkDirectEdit(verifier, diagram, inputLabel, d -> this.getOutsideLabelid(mainNodeId, d), checker); + this.checkDirectEdit(verifier, diagram, inputLabel, d -> this.getOutsideLabelId(mainNodeId, d), checker); + } + + /** + * Creates a runnable that executes a direct edit on an {@link InsideLabel}. + * + * @param diagram + * the diagram reference + * @param mainNodeId + * the id of the node holding the inside label + * @param inputLabel + * the input label to be used for the direct edit + * @return a runnable that performs the direct edit mutation + */ + public Runnable directEditInsideLabel(AtomicReference diagram, String mainNodeId, String inputLabel) { + return this.createDirectEditRunnable(diagram, inputLabel, d -> this.getInsideLabelId(mainNodeId, d)); + } + + /** + * Creates a runnable that executes a direct edit on an {@link OutsideLabel}. + * + * @param diagram + * the diagram reference + * @param mainNodeId + * the id of the node holding the outside label + * @param inputLabel + * the input label to be used for the direct edit + * @return a runnable that performs the direct edit mutation + */ + public Runnable directEditOutsideLabel(AtomicReference diagram, String mainNodeId, String inputLabel) { + return this.createDirectEditRunnable(diagram, inputLabel, d -> this.getOutsideLabelId(mainNodeId, d)); } + /** + * Creates a runnable that executes a direct edit on an edge centered label. + * + * @param diagram + * the diagram reference + * @param edgeId + * the id of the edge holding the centered label + * @param inputLabel + * the input label to be used for the direct edit + * @return a runnable that performs the direct edit mutation + */ + public Runnable directEditCenteredEdgeLabel(AtomicReference diagram, String edgeId, String inputLabel) { + return this.createDirectEditRunnable(diagram, inputLabel, d -> this.getCenteredLabelId(edgeId, d)); + } + + private Runnable createDirectEditRunnable(AtomicReference diagram, String inputLabel, Function labelIdProvider) { + return () -> { + final String labelId = labelIdProvider.apply(diagram.get()); + EditLabelInput input = new EditLabelInput(UUID.randomUUID(), this.editingContextId, diagram.get().getId(), labelId, inputLabel); + var result = this.editLabelMutationRunner.run(input); + String typename = JsonPath.read(result.data(), "$.data.editLabel.__typename"); + assertThat(typename).isEqualTo(EditLabelSuccessPayload.class.getSimpleName()); + }; + } + + /** + * Executes a direct edit mutation and chains the result verification to the provided verifier. + * + * @param verifier + * the {@link Step} verifier to chain the direct edit execution to + * @param diagram + * the diagram reference containing the label to edit + * @param inputLabel + * the new label value to set via direct edit + * @param labelIdProvider + * a function that retrieves the label ID from the diagram + * @param diagramConsumer + * a consumer to verify the diagram after the direct edit completes + * @deprecated use {@link #createDirectEditRunnable(AtomicReference, String, Function)} instead. + */ + @Deprecated private void checkDirectEdit(Step verifier, AtomicReference diagram, String inputLabel, Function labelIdProvider, Consumer diagramConsumer) { Runnable requestDirectEdit = () -> { @@ -193,7 +274,7 @@ private String getInsideLabelId(String mainNodeId, Diagram d) { return diagramNavigator.nodeWithId(mainNodeId).getNode().getInsideLabel().getId(); } - private String getOutsideLabelid(String mainNodeId, Diagram d) { + private String getOutsideLabelId(String mainNodeId, Diagram d) { DiagramNavigator diagramNavigator = new DiagramNavigator(d); return diagramNavigator.nodeWithId(mainNodeId).getNode().getOutsideLabels().get(0).id(); }