protected AbstractDiagramValidator(final DefinitionManager definitionManager, final RuleManager ruleManager, final TreeWalkTraverseProcessor treeWalkTraverseProcessor, final ModelValidator modelValidator) { this.graphValidator = new GraphValidatorImpl(definitionManager, ruleManager, treeWalkTraverseProcessor); this.modelValidator = modelValidator; }
@Override @SuppressWarnings("unchecked") public void validate(final Graph graph, final Consumer<Collection<RuleViolation>> callback) { validate(graph, null, callback); }
@SuppressWarnings("unchecked") private RuleViolations evaluateCardinality(final RuleSet ruleSet, final Graph graph) { log(" CARDINALITY [graph=" + graph + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.cardinality(graph, Optional.empty(), Optional.empty())); }
final Optional<BiConsumer<Edge, Collection<RuleViolation>>> edgeValidatorConsumer, Consumer<Collection<RuleViolation>> resultConsumer) { final RuleSet ruleSet = aRuleSet.orElse(getRuleSet(graph)); final ViolationsSet violations = new ViolationsSet(); treeWalkTraverseProcessor
@Override public void validate(final Graph graph, final RuleSet ruleSet, final Consumer<Collection<RuleViolation>> callback) { this.validate(graph, Optional.ofNullable(ruleSet), Optional.empty(), Optional.empty(), Optional.empty(), callback); }
@Before @SuppressWarnings("unchecked") public void setup() throws Exception { this.graphTestHandler = new TestingGraphMockHandler(); when(graphTestHandler.definitionSetRegistry.getDefinitionSetById(eq(DEF_SET_ID))).thenReturn(defSetBean); when(graphTestHandler.ruleAdapter.getRuleSet(eq(defSetBean))).thenReturn(graphTestHandler.ruleSet); this.tested = new GraphValidatorImpl(graphTestHandler.definitionManager, graphTestHandler.ruleManager, new TreeWalkTraverseProcessorImpl()); }
/** * Actually the different commands allows removing nodes that have * incoming or outgoing view connectors, as connectors can be re-attached to * a different node, but the graph structure is not considered valid, so the * diagram cannot be updated until fixing that connections. * So there exist no rule for empty connections, actually it's just a common validation. */ @SuppressWarnings("unchecked") private Optional<RuleViolation> evaluateNotEmptyConnections(final Graph<?, ? extends Node> graph, final Edge<? extends View<?>, ? extends Node> connector, final Optional<Node<? extends View<?>, ? extends Edge>> sourceNode, final Optional<Node<? extends View<?>, ? extends Edge>> targetNode) { log(" NOT_EMPTY_CONNECTIONS " + "[edge=" + connector + ",source=" + sourceNode.orElse(null) + ",target=" + targetNode.orElse(null) + "]"); if (!sourceNode.isPresent() || !targetNode.isPresent()) { return Optional.of(EmptyConnectionViolation.Builder.build(connector, sourceNode, targetNode)); } return Optional.empty(); }
@Override @SuppressWarnings("unchecked") public void validate(final Diagram diagram, final Consumer<Collection<DiagramElementViolation<RuleViolation>>> resultConsumer) { final Graph graph = diagram.getGraph(); final List<DiagramElementViolation<RuleViolation>> violations = new LinkedList<>(); graphValidator.validate(graph, Optional.empty(), Optional.of((g, v) -> consumeBeanAndViolations(() -> violations).accept(g, v)), Optional.of((n, v) -> consumeBeanAndViolations(() -> violations).accept(n, v)), Optional.of((e, v) -> consumeBeanAndViolations(() -> violations).accept(e, v)), // At this point all violations have been already consumed, so no need // to use the resulting ones here. vs -> resultConsumer.accept(violations) ); }
@SuppressWarnings("unchecked") private RuleViolations evaluateConnection(final RuleSet ruleSet, final Graph<?, ? extends Node> graph, final Edge<? extends View<?>, ? extends Node> connector, final Optional<Node<? extends View<?>, ? extends Edge>> sourceNode, final Optional<Node<? extends View<?>, ? extends Edge>> targetNode) { log(" CONNECTION " + "[edge=" + connector + ",source=" + sourceNode.orElse(null) + ",target=" + targetNode.orElse(null) + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.connection(graph, connector, sourceNode, targetNode)); }
final Graph<DefinitionSet, Node> graph = graphTestHandler.graph; final TestingGraphInstanceBuilder.TestGraph2 testGraph2 = TestingGraphInstanceBuilder.newGraph2(graphTestHandler); tested.validate(getGraph(), graphTestHandler.ruleSet, this::assertNoError);
@SuppressWarnings("unchecked") private RuleViolations evaluateContainment(final RuleSet ruleSet, final Graph graph, final Element<? extends Definition<?>> parent, final Node candidate) { log(" CONTAINMENT " + "[parent=" + parent + ",candidate=" + candidate + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.containment(graph, parent, candidate)); }
final Graph<DefinitionSet, Node> graph = graphTestHandler.graph; final TestingGraphInstanceBuilder.TestGraph1 testGraph1 = TestingGraphInstanceBuilder.newGraph1(graphTestHandler); tested.validate(graph, ruleSet, this::assertNoError);
@SuppressWarnings("unchecked") private RuleViolations evaluateIncomingEdgeCardinality(final RuleSet ruleSet, final org.kie.workbench.common.stunner.core.graph.Graph graph, final Edge<? extends View, Node> edge) { log(" IN-EDGE CARDINALITY [edge=" + edge + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.edgeCardinality(graph, edge.getTargetNode(), (Edge<? extends View<?>, Node>) edge, EdgeCardinalityContext.Direction.INCOMING, Optional.empty())); }
@Test @SuppressWarnings("unchecked") public void testValidateEmptyViewConnectorNodes() { final RuleSet ruleSet = graphTestHandler.ruleSet; final Graph<DefinitionSet, Node> graph = graphTestHandler.graph; final TestingGraphInstanceBuilder.TestGraph1 testGraph1 = TestingGraphInstanceBuilder.newGraph1(graphTestHandler); // Update the edge2 and remove the connection's target node. // From this point, a validation error is expected. graphTestHandler.removeTargetConnection(testGraph1.edge2); tested.validate(graph, ruleSet, ruleViolations -> { assertEquals(1, ruleViolations.size()); final RuleViolation violation = ruleViolations.iterator().next(); assertNotNull(violation); assertTrue(violation instanceof EmptyConnectionViolation); EmptyConnectionViolation v = (EmptyConnectionViolation) violation; final Optional<Object[]> arguments = v.getArguments(); assertTrue(arguments.isPresent()); assertEquals(testGraph1.edge2.getUUID(), arguments.get()[0]); assertEquals(testGraph1.intermNode.getUUID(), arguments.get()[1]); assertNull(arguments.get()[2]); }); }
@SuppressWarnings("unchecked") private RuleViolations evaluateOutgoingEdgeCardinality(final RuleSet ruleSet, final org.kie.workbench.common.stunner.core.graph.Graph graph, final Edge<? extends View, Node> edge) { log(" OUT-EDGE CARDINALITY [edge=" + edge + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.edgeCardinality(graph, edge.getSourceNode(), (Edge<? extends View<?>, Node>) edge, EdgeCardinalityContext.Direction.OUTGOING, Optional.empty())); }
@SuppressWarnings("unchecked") private RuleViolations evaluateDocking(final RuleSet ruleSet, final Graph graph, final Element<? extends Definition<?>> parent, final Node candidate) { log(" DOCKING " + "[parent=" + (parent.getUUID()) + ",candidate=" + candidate.getUUID() + "]"); return ruleManager .evaluate(ruleSet, RuleContextBuilder.GraphContexts.docking(graph, parent, candidate)); }