src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
@Test public void testHideNullControl() { popover.hide(); verify(view, never()).hide(); }
|
AbstractAppendNodeShortcut implements KeyboardShortcut<AbstractCanvasHandler> { @Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } } AbstractAppendNodeShortcut(final ToolboxDomainLookups toolboxDomainLookups,
final DefinitionsCacheRegistry definitionsCacheRegistry,
final GeneralCreateNodeAction generalCreateNodeAction); @Override void executeAction(final AbstractCanvasHandler canvasHandler,
final String selectedNodeId); abstract boolean canAppendNodeOfDefinition(final Object definition); }
|
@Test public void testAppend() { final Object targetNodeDefinition = mock(Object.class); testedShortcut = new AbstractAppendNodeShortcutMock(targetNodeDefinition); selectedNodeId = "selected"; targetDefinitionNodeId = "target"; connectorDefinitionId = "connector"; definitionSetId = "definition"; when(canvasHandler.getGraphIndex()).thenReturn(graphIndex); when(canvasHandler.getDiagram()).thenReturn(diagram); when(diagram.getGraph()).thenReturn(graph); when(diagram.getMetadata()).thenReturn(metadata); when(metadata.getDefinitionSetId()).thenReturn(definitionSetId); final Element selectedElement = mock(Element.class); when(graphIndex.get(selectedNodeId)).thenReturn(selectedElement); final Node selectedNode = mock(Node.class); when(selectedElement.asNode()).thenReturn(selectedNode); when(toolboxDomainLookups.get(definitionSetId)).thenReturn(commonDomainLookups); final Set<String> connectorDefinitionIds = Collections.singleton(connectorDefinitionId); when(commonDomainLookups.lookupTargetConnectors(selectedNode)).thenReturn(connectorDefinitionIds); final Set<String> targetNodesDefinitionIds = Collections.singleton(targetDefinitionNodeId); when(commonDomainLookups.lookupTargetNodes(graph, selectedNode, connectorDefinitionId)).thenReturn(targetNodesDefinitionIds); when(definitionsCacheRegistry.getDefinitionById(targetDefinitionNodeId)).thenReturn(targetNodeDefinition); testedShortcut.executeAction(canvasHandler, selectedNodeId); verify(generalCreateNodeAction).executeAction(canvasHandler, selectedNodeId, targetDefinitionNodeId, connectorDefinitionId); reset(definitionsCacheRegistry); reset(generalCreateNodeAction); when(definitionsCacheRegistry.getDefinitionById(targetDefinitionNodeId)).thenReturn(new Object()); testedShortcut.executeAction(canvasHandler, selectedNodeId); verify(generalCreateNodeAction, never()).executeAction(any(), any(), any(), any()); }
|
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } @Inject KeyboardControlImpl(final SessionManager clientSessionManager,
final KeyEventHandler keyEventHandler); @Override KeyboardControl<AbstractCanvas, ClientSession> addKeyShortcutCallback(final KeyShortcutCallback shortcutCallback); void setKeyEventHandlerEnabled(final boolean enabled); @Override void bind(final ClientSession session); }
|
@Test public void testSetKeyEventHandlerEnabled() { tested.setKeyEventHandlerEnabled(true); verify(keyEventHandler, times(1)).setEnabled(eq(true)); }
|
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } @Override KeyEventHandler addKeyShortcutCallback(final KeyboardControl.KeyShortcutCallback shortcutCallback); @Override KeyEventHandler setTimerDelay(final int millis); @Override @PreDestroy void clear(); @Override void setEnabled(final boolean enabled); void onKeyUpEvent(final @Observes KeyUpEvent event); }
|
@Test public void testOnKeyUp() { tested.onKeyUpEvent(new KeyUpEvent(KeyboardEvent.Key.ALT)); verify(shortcutCallback, times(1)).onKeyUp(eq(KeyboardEvent.Key.ALT)); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test public void testAllow() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 0); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 1); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 3); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndex() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.allow(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCP() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.allow(canvasHandler); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndexDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.execute(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCPDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.execute(canvasHandler); }
@Test public void execute() { checkExecution(true); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge<? extends View<?>, Node> getEdge(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(edgeShape, times(1)).applyConnections(eq(edge), eq(sourceShapeView), eq(targetShapeView), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
@Test @SuppressWarnings("unchecked") public void testExecuteAndUpdateMagnetLocations() { final MagnetConnection sourceConnection = new MagnetConnection.Builder() .magnet(0) .build(); final MagnetConnection targetConnection = new MagnetConnection.Builder() .magnet(0) .build(); when(edgeContent.getSourceConnection()).thenReturn(Optional.of(sourceConnection)); when(edgeContent.getTargetConnection()).thenReturn(Optional.of(targetConnection)); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(edgeShape, times(1)).applyConnections(eq(edge), eq(sourceShapeView), eq(targetShapeView), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); assertEquals(5d, sourceConnection.getLocation().getX(), 0d); assertEquals(5d, sourceConnection.getLocation().getY(), 0d); assertEquals(10d, targetConnection.getLocation().getX(), 0d); assertEquals(10d, targetConnection.getLocation().getY(), 0d); }
|
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
@Test public void testCreateOptions() { final PopoverOptions options = mock(PopoverOptions.class); doReturn(options).when(view).createPopoverOptionsInstance(); view.createOptions(); verify(options).setAnimation(false); verify(options).setHtml(true); verify(options).setPlacement(AbstractPopoverViewImpl.PLACEMENT); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
@Test public void testNewGraphCommand() { final Command<GraphCommandExecutionContext, RuleViolation> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newGraphCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyValueCommand.class); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
@Test public void testNewCanvasCommandExecute() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.execute(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); }
@Test public void testNewCanvasCommandUndo() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.undo(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); }
|
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } AddCanvasConnectorCommand(final Edge candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); String getShapeSetId(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(candidateShape, times(1)).applyConnections(eq(candidate), eq(sourceShapeView), any(ShapeView.class), any(MutationContext.class)); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).addChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, times(0)).dock(any(Node.class), any(Node.class)); verify(connectorShapeView1, times(1)).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, times(1)).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); }
@Test @SuppressWarnings("unchecked") public void testSkipExecutionAsDockIsPresent() { final Edge dockEdge = mock(Edge.class); when(dockEdge.getContent()).thenReturn(new Dock()); graph1Instance.intermNode.getInEdges().add(dockEdge); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, never()).addChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, never()).dock(any(Node.class), any(Node.class)); verify(connectorShapeView1, never()).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, never()).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }
|
@Test public void testGetGraphCommand() { final org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(candidate, graphCommand.getEdge()); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }
|
@Test public void testGetCanvasCommand() { final DeleteCanvasConnectorCommand canvasCommand = (DeleteCanvasConnectorCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); assertEquals(candidate, canvasCommand.getCandidate()); }
|
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } UpdateCanvasElementPropertyCommand(final Element element); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementProperties(eq(candidate), any(MutationContext.class)); }
|
AbstractPopoverViewImpl implements PopoverView { public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
@Test public void testOnClosedByKeyboard() { final Consumer consumer = mock(Consumer.class); final Optional opt = Optional.of(consumer); doReturn(opt).when(view).getClosedByKeyboardCallback(); view.onClosedByKeyboard(); verify(consumer).accept(view); }
|
AddCanvasChildNodeCommand extends AbstractRegistrationCanvasNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; } AddCanvasChildNodeCommand(final Node parent,
final Node candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).addChild(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).clearCanvas(); }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = UnsupportedOperationException.class) public void testUndo() { tested.undo(canvasHandler); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
@Test public void startNodeTestGraphCommand() { this.tested = new DeleteNodeCommand(graphHolder.startNode); final org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(graphHolder.startNode, graphCommand.getNode()); }
@Test public void intermediateNodeTestGraphCommand() { this.tested = new DeleteNodeCommand(graphHolder.intermNode); final org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(graphHolder.intermNode, graphCommand.getNode()); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { CompositeCommand<AbstractCanvasHandler, CanvasViolation> getCommand() { return deleteProcessor.getCommand(); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
@Test public void testMoveChildToCanvasRoot() { final DeleteNodeCommand.CanvasDeleteProcessor processor = mock(DeleteNodeCommand.CanvasDeleteProcessor.class); final Node node = mock(Node.class); final Element elementCanvas = mock(Element.class); final Node canvasNode = mock(Node.class); final Element parentElement = mock(Element.class); final Node nodeParent = mock(Node.class); final Point2D newPosition = new Point2D(1, 2); final CompositeCommand command = mock(CompositeCommand.class); when(elementCanvas.asNode()).thenReturn(canvasNode); doCallRealMethod().when(processor).moveChildToCanvasRoot(elementCanvas, node); when(parentElement.asNode()).thenReturn(nodeParent); when(processor.getParent(node)).thenReturn(parentElement); when(processor.getCommand()).thenReturn(command); when(processor.getChildPosition(node, parentElement)).thenReturn(newPosition); processor.moveChildToCanvasRoot(elementCanvas, node); verify(command, times(3)).addCommand(commandsCaptor.capture()); final List<AbstractCanvasGraphCommand> values = commandsCaptor.getAllValues(); final AbstractCanvasGraphCommand removeChildrenCmd = values.get(0); final AbstractCanvasGraphCommand setChildrenCmd = values.get(1); final AbstractCanvasGraphCommand updatePosition = values.get(2); assertTrue(removeChildrenCmd instanceof RemoveChildrenCommand); assertTrue(setChildrenCmd instanceof SetChildrenCommand); assertTrue(updatePosition instanceof UpdateElementPositionCommand); assertEquals(nodeParent, ((RemoveChildrenCommand) removeChildrenCmd).getParent()); assertEquals(canvasNode, ((SetChildrenCommand) setChildrenCmd).getParent()); assertEquals(node, ((UpdateElementPositionCommand) updatePosition).getElement()); assertEquals(node, getNode(((RemoveChildrenCommand) removeChildrenCmd).getChildren())); assertEquals(node, getNode(((SetChildrenCommand) setChildrenCmd).getCandidates())); assertEquals(newPosition, ((UpdateElementPositionCommand) updatePosition).getLocation()); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }
|
@Test public void newGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> command = cloneConnectorCommand.newGraphCommand(context); assertTrue(command instanceof org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void newCanvasCommand() { Command<AbstractCanvasHandler, CanvasViolation> command = cloneConnectorCommand.newCanvasCommand(context); assertTrue(command instanceof CompositeCommand); Consumer<Edge> cloneCallback = cloneConnectorCommand.getCloneCallback(); cloneCallback.accept(clone); CompositeCommand compositeCommand = (CompositeCommand) command; assertTrue(compositeCommand.getCommands().stream().anyMatch(c -> c instanceof AddCanvasConnectorCommand)); assertEquals(((AddCanvasConnectorCommand) compositeCommand.getCommands().stream() .filter(c -> c instanceof AddCanvasConnectorCommand) .findFirst() .get()).getCandidate(), clone); assertTrue(compositeCommand.getCommands().stream().anyMatch(c -> c instanceof SetCanvasConnectionCommand)); assertEquals(((SetCanvasConnectionCommand) compositeCommand.getCommands().stream() .filter(c -> c instanceof SetCanvasConnectionCommand) .findFirst() .get()).getEdge(), clone); }
|
CanvasDockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { getCandidate().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.removeChild(e.getSourceNode(), candidate)); ShapeView shapeView = context.getCanvas().getShape(candidate.getUUID()).getShapeView(); Point2D currentPosition = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); context.applyElementMutation(parent, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } Point2D dockLocation = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); if (!Objects.equals(currentPosition, dockLocation)) { dockedPositionCallback.ifPresent(callback -> callback.accept(dockLocation)); } return buildResult(); } CanvasDockNodeCommand(final Node parent,
final Node candidate); CanvasDockNodeCommand(final Node parent,
final Node candidate,
final Consumer<Point2D> dockedPositionCallback); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(0)).register(anyString(), eq(candidate)); verify(canvasHandler, times(0)).addChild(any(Node.class), any(Node.class)); verify(canvasHandler, times(1)).dock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
@Test @SuppressWarnings("unchecked") public void testExecuteNullSourceNode() { when(candidate.getSourceNode()).thenReturn(null); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, never()).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
@Test @SuppressWarnings("unchecked") public void testExecuteNullTargetNode() { when(candidate.getTargetNode()).thenReturn(null); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, never()).notifyCanvasElementUpdated(eq(target)); }
@Test public void testExecuteNullShape() { when(canvas.getShape(EDGE_ID)).thenReturn(null); assertFalse(CommandUtils.isError(tested.execute(canvasHandler))); verify(canvasHandler, never()).deregister(eq(candidate)); }
|
AbstractPopoverViewImpl implements PopoverView { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
@Test public void testSetOnClosedByKeyboardCallback() { final Consumer consumer = mock(Consumer.class); view.setOnClosedByKeyboardCallback(consumer); final Optional<Consumer<CanBeClosedByKeyboard>> actual = view.getClosedByKeyboardCallback(); assertTrue(actual.isPresent()); assertEquals(consumer, actual.get()); }
|
UpdateCanvasElementPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; } UpdateCanvasElementPositionCommand(final Element<? extends View<?>> element,
final Point2D location); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Element<? extends View<?>> getElement(); Point2D getLocation(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteSuccess() { tested = new UpdateCanvasElementPositionCommand(candidate, Point2D.create(0d, 0d)); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementPosition(eq(candidate), any(MutationContext.class)); }
|
AddCanvasDockedNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); } AddCanvasDockedNodeCommand(final Node parent,
final Node candidate,
final String ssid); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).dock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); verify(canvasHandler, never()).addChild(eq(parent), eq(candidate)); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(AbstractCanvasHandler context) { commands = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .reverse() .build(); commands.addCommand(createAddCanvasChildNodeCommand(getParent(), getCandidate(), getShapeSetId())); if (GraphUtils.hasChildren(getCandidate())) { Graph graph = context.getGraphIndex().getGraph(); List<Edge> clonedEdges = new ArrayList<>(); childrenTraverseProcessor.get() .setRootUUID(getCandidate().getUUID()) .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) { commands.addCommand(createCloneCanvasNodeCommand(getCandidate(), node, getShapeSetId())); clonedEdges.addAll(node.getOutEdges()); return false; } }); clonedEdges.stream() .filter(edge -> edge.getContent() instanceof Dock) .forEach(edge -> commands.addCommand(new CanvasDockNodeCommand(edge.getSourceNode(), edge.getTargetNode()))); clonedEdges .stream() .filter(edge -> edge.getContent() instanceof ViewConnector) .forEach(edge -> commands.addCommand(new AddCanvasConnectorCommand((Edge) edge, getShapeSetId()))); } if (GraphUtils.hasDockedNodes(getCandidate())) { List<Edge> edges = getCandidate().getOutEdges(); edges.stream() .filter(edge -> edge.getContent() instanceof Dock) .map(edge -> edge.getTargetNode()) .forEach(targetNode -> { commands.addCommand(new AddCanvasChildNodeCommand(getParent(), targetNode, getShapeSetId())); commands.addCommand(new CanvasDockNodeCommand(getCandidate(), targetNode)); }); } return commands.execute(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }
|
@Test public void testExecute() { cloneCanvasNodeCommand.execute(canvasHandler); AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> commands = cloneCanvasNodeCommand.getCommands(); assertEquals(commands.size(), 6); assertTrue(commands.getCommands().stream() .filter(command -> command instanceof CloneCanvasNodeCommand) .map(command -> (CloneCanvasNodeCommand) command) .allMatch(command -> Objects.equals(command.getCandidate(), graphInstance.startNode) || Objects.equals(command.getCandidate(), graphInstance.intermNode) || Objects.equals(command.getCandidate(), graphInstance.endNode))); assertTrue(commands.getCommands().stream() .filter(command -> command instanceof AddCanvasConnectorCommand) .map(command -> (AddCanvasConnectorCommand) command) .allMatch(command -> Objects.equals(command.getCandidate(), graphInstance.edge1) || Objects.equals(command.getCandidate(), graphInstance.edge2))); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }
|
@Test public void testUndo() { testExecute(); cloneCanvasNodeCommand.undo(canvasHandler); verify(canvasHandler, atLeastOnce()).removeChild(parent, candidate); verify(canvasHandler, atLeastOnce()).deregister(candidate); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.startNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.startNode); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.intermNode); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.endNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.endNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.edge1); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.edge2); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).removeChild(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }
|
@Test public void testUndo() { tested.undo(canvasHandler); verify(canvasHandler).register(SHAPE_SET_ID, candidate); verify(canvasHandler).addChild(parent, candidate); }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { @Override @SuppressWarnings("unchecked") protected AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> initialize(final AbstractCanvasHandler context) { super.initialize(context); widthBefore = candidate.getContent().getBounds().getWidth(); heightBefore = candidate.getContent().getBounds().getHeight(); final double w = boundingBox.getMaxX(); final double h = boundingBox.getMaxY(); final List<Command<AbstractCanvasHandler, CanvasViolation>> commands = getResizeCommands(context, w, h); if (null != commands) { final Node<View<?>, Edge> node = (Node<View<?>, Edge>) candidate; commands.forEach(this::addCommand); if (GraphUtils.hasDockedNodes(node)) { updateDockedNodesPosition(context, node); } if (GraphUtils.hasConnections(node)) { updateConnectionsPositions(context, node); } } return this; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); Element<? extends View> getCandidate(); BoundingBox getBoundingBox(); BiFunction<Shape, Integer, Point2D> getMagnetLocationProvider(); Consumer<Shape> getOnResize(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testInitialize() { AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> command = tested.initialize(canvasHandler); assertNotNull(command); final List commands = command.getCommands(); assertNotNull(commands); assertEquals(6, commands.size()); assertTrue(commands.get(0) instanceof UpdateElementPropertyCommand); final UpdateElementPropertyCommand wPropertyCommand = (UpdateElementPropertyCommand) commands.get(0); assertEquals(element, wPropertyCommand.getElement()); assertEquals(W_PROPERTY_ID, wPropertyCommand.getField()); assertEquals(boundingBox.getWidth(), wPropertyCommand.getValue()); assertTrue(commands.get(1) instanceof UpdateElementPropertyCommand); final UpdateElementPropertyCommand hPropertyCommand = (UpdateElementPropertyCommand) commands.get(1); assertEquals(element, hPropertyCommand.getElement()); assertEquals(H_PROPERTY_ID, hPropertyCommand.getField()); assertEquals(boundingBox.getHeight(), hPropertyCommand.getValue()); assertTrue(commands.get(2) instanceof UpdateElementPropertyCommand); final UpdateElementPropertyCommand rPropertyCommand = (UpdateElementPropertyCommand) commands.get(2); assertEquals(element, rPropertyCommand.getElement()); assertEquals(R_PROPERTY_ID, rPropertyCommand.getField()); assertEquals(50d, rPropertyCommand.getValue()); verify(magnetLocationProvider, times(1)).apply(eq(shape), eq(0)); verify(magnetLocationProvider, times(1)).apply(eq(shape), eq(1)); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test public void testShow() { final PopupEditorControls editor = mock(PopupEditorControls.class); final int x = 10; final int y = 20; final HTMLElement element = mock(HTMLElement.class); doReturn(element).when(view).getElement(); final CSSStyleDeclaration style = mock(CSSStyleDeclaration.class); when(element.getStyle()).thenReturn(style); view.show(editor, x, y); verify(style).setProperty(LEFT, x + PX); verify(style).setProperty(TOP, y + PX); verify(view).setOnClosedByKeyboardCallback(editor); verify(editor).show(); }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { CommandResult<CanvasViolation> postOperation(final AbstractCanvasHandler context, final CommandResult<CanvasViolation> result, final double width, final double height) { if (!CommandUtils.isError(result)) { final Point2D current = GraphUtils.getPosition(candidate.getContent()); final Bounds newBounds = Bounds.create(current.getX(), current.getY(), current.getX() + width, current.getY() + height); candidate.getContent().setBounds(newBounds); final ShapeView shapeView = getShape(context, candidate.getUUID()).getShapeView(); ShapeUtils.setSizeFromBoundingBox(shapeView, width, height); onResize.accept(getShape(context, candidate.getUUID())); } return result; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); Element<? extends View> getCandidate(); BoundingBox getBoundingBox(); BiFunction<Shape, Integer, Point2D> getMagnetLocationProvider(); Consumer<Shape> getOnResize(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testPostOperation() { CommandResult<CanvasViolation> result = CanvasCommandResultBuilder.SUCCESS; CommandResult<CanvasViolation> cascasded = tested.postOperation(canvasHandler, result, 100, 200); assertEquals(result, cascasded); verify(onResize, times(1)).accept(eq(shape)); ArgumentCaptor<Bounds> boundsArgumentCaptor = ArgumentCaptor.forClass(Bounds.class); verify(elementContent, times(1)).setBounds(boundsArgumentCaptor.capture()); assertEquals(Bounds.create(10, 20, 110, 220), boundsArgumentCaptor.getValue()); }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); } @Override String toString(); }
|
@Test public void testGetGraphCommand() { final ClearGraphCommand graphCommand = (ClearGraphCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(CANVAS_ROOT_UUID, graphCommand.getRootUUID()); }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); } @Override String toString(); }
|
@Test public void testGetCanvasCommand() { final ClearCanvasCommand canvasCommand = (ClearCanvasCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); }
|
UpdateElementPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); } UpdateElementPropertyCommand(final Element element,
final String field,
final Object value); Element getElement(); String getField(); Object getValue(); @Override String toString(); }
|
@Test public void testNewGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> command; String propertyId = "name"; String value = "updated value"; command = new UpdateElementPropertyCommand(element, propertyId, value).newGraphCommand(abstractCanvasHandler); assertEquals(command.getClass(), UpdateElementPropertyValueCommand.class); command = new UpdateElementPropertyCommand(node, propertyId, value).newGraphCommand(abstractCanvasHandler); assertEquals(command.getClass(), UpdateElementPropertyValueCommand.class); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testMorphDockedNode() { TestingGraphInstanceBuilder.TestGraph4 graphInstance = mockGraph4(); this.tested = new MorphCanvasNodeCommand(graphInstance.dockedNode, NEW_SHAPE_SET_ID); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertFalse(CommandUtils.isError(result)); verify(canvasHandler, times(1)).deregister(graphInstance.dockedNode); verify(canvasHandler, times(1)).register(NEW_SHAPE_SET_ID, graphInstance.dockedNode); verify(canvasHandler, times(1)).undock(graphInstance.intermNode, graphInstance.dockedNode); verify(canvasHandler, times(1)).dock(graphInstance.intermNode, graphInstance.dockedNode); verify(canvasHandler, times(1)).applyElementMutation(graphInstance.dockedNode, MutationContext.STATIC); verify(canvasHandler, never()).removeChild(anyObject(), anyObject()); verify(canvasHandler, never()).addChild(anyObject(), anyObject()); verify(edge1ShapeView, never()).moveToTop(); verify(edge2ShapeView, never()).moveToTop(); }
@Test @SuppressWarnings("unchecked") public void testMorphSomeIntermediateNode() { TestingGraphInstanceBuilder.TestGraph4 graphInstance = mockGraph4(); this.tested = new MorphCanvasNodeCommand(graphInstance.intermNode, NEW_SHAPE_SET_ID); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertFalse(CommandUtils.isError(result)); verify(canvasHandler, times(1)).undock(eq(graphInstance.intermNode), eq(graphInstance.dockedNode)); verify(canvasHandler, times(1)).removeChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, times(1)).deregister(graphInstance.intermNode); verify(canvasHandler, times(1)).register(NEW_SHAPE_SET_ID, graphInstance.intermNode); verify(canvasHandler, times(1)).addChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, times(1)).dock(eq(graphInstance.intermNode), eq(graphInstance.dockedNode)); verify(canvasHandler, times(1)).applyElementMutation(graphInstance.intermNode, MutationContext.STATIC); verify(edge1ShapeView, times(1)).moveToTop(); verify(edge2ShapeView, times(1)).moveToTop(); }
@Test @SuppressWarnings("unchecked") public void testMorphSomeContainerNode() { TestingGraphInstanceBuilder.TestGraph3 graphInstance = mockGraph3(); this.tested = new MorphCanvasNodeCommand(graphInstance.containerNode, NEW_SHAPE_SET_ID); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertFalse(CommandUtils.isError(result)); verify(canvasHandler, times(1)).deregister(graphInstance.containerNode); verify(canvasHandler, times(1)).removeChild(graphInstance.parentNode, graphInstance.containerNode); verify(canvasHandler, times(1)).removeChild(graphInstance.containerNode, graphInstance.startNode); verify(canvasHandler, times(1)).removeChild(graphInstance.containerNode, graphInstance.intermNode); verify(canvasHandler, times(1)).removeChild(graphInstance.containerNode, graphInstance.endNode); verify(canvasHandler, times(1)).register(NEW_SHAPE_SET_ID, graphInstance.containerNode); verify(canvasHandler, times(1)).addChild(graphInstance.parentNode, graphInstance.containerNode); verify(canvasHandler, times(1)).addChild(graphInstance.containerNode, graphInstance.startNode); verify(canvasHandler, times(1)).addChild(graphInstance.containerNode, graphInstance.intermNode); verify(canvasHandler, times(1)).addChild(graphInstance.containerNode, graphInstance.endNode); verify(canvasHandler, times(1)).applyElementMutation(graphInstance.containerNode, MutationContext.STATIC); verify(edge1ShapeView, times(1)).moveToTop(); verify(edge2ShapeView, times(1)).moveToTop(); }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
@Test @SuppressWarnings("unchecked") public void testAllow() { CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, times(1)).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.INFO, result.getType()); assertFalse(result.getViolations().iterator().hasNext()); }
@Test @SuppressWarnings("unchecked") public void testCanvasCommandNotAllowed() { when(canvasCommand.allow(eq(canvasHandler))).thenReturn(CANVAS_COMMAND_FAILED); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, times(1)).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.ERROR, result.getType()); }
@Test @SuppressWarnings("unchecked") public void testGraphCommandNotAllowed() { when(graphCommand.allow(eq(graphContext))).thenReturn(GRAPH_COMMAND_FAILED); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, never()).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.ERROR, result.getType()); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test public void testSetOnClosedByKeyboardCallback() { final PopupEditorControls editor = mock(PopupEditorControls.class, withSettings().extraInterfaces(CanBeClosedByKeyboard.class)); view.setOnClosedByKeyboardCallback(editor); verify((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(any()); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Path getDMNModelPath(final Metadata metadata, final String modelNamespace, final String modelName) { final WorkspaceProject workspaceProject = getProject(metadata); for (final Path dmnModelPath : pathsHelper.getDMNModelsPaths(workspaceProject)) { final Optional<Definitions> definitions = getDefinitionsByPath(dmnModelPath); if (definitions.map(d -> Objects.equals(d.getNamespace(), modelNamespace) && Objects.equals(d.getName(), modelName)).orElse(false)) { return dmnModelPath; } } throw new IllegalStateException("A path for the DMN model with namespace [" + modelNamespace + "] could not be found."); } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); static final QName NAMESPACE; }
|
@Test public void testGetModelPathWhenDMNModelCouldNotBeFound() { final Metadata metadata = mock(Metadata.class); final String modelNamespace = "0000-1111-2222-3333"; final String modelName = "model name"; assertThatThrownBy(() -> helper.getDMNModelPath(metadata, modelNamespace, modelName)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("A path for the DMN model with namespace [0000-1111-2222-3333] could not be found."); }
|
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public String getContent(final Path path) { return getSource(path); } @Inject DMNContentServiceImpl(final CommentedOptionFactory commentedOptionFactory,
final DMNIOHelper dmnIOHelper,
final DMNPathsHelper pathsHelper,
final PMMLIncludedDocumentFactory pmmlIncludedDocumentFactory); @Override String getContent(final Path path); @Override DMNContentResource getProjectContent(final Path path,
final String defSetId); @Override void saveContent(final Path path,
final String content,
final Metadata metadata,
final String comment); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override PMMLDocumentMetadata loadPMMLDocumentMetadata(final Path path); @Override String getSource(final Path path); }
|
@Test public void testGetContent() { final String actual = "<xml/>"; doReturn(actual).when(service).getSource(path); final String expected = service.getContent(path); assertEquals(expected, actual); }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<CanvasViolation> result = tested.execute(canvasHandler); verify(graphCommand, times(1)).execute(eq(graphContext)); verify(canvasCommand, times(1)).execute(eq(canvasHandler)); assertEquals(CommandResult.Type.INFO, result.getType()); assertFalse(result.getViolations().iterator().hasNext()); }
|
DrawCanvasCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Graph graph = context.getGraphIndex().getGraph(); final String shapeSetId = getShapeSetId(context); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>().forward(); childrenTraverseProcessor .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { private Map<String, Boolean> processedNodes = new HashMap<>(); @Override public void startNodeTraversal(final Node<View, Edge> node) { super.startNodeTraversal(node); if (!isCanvasRoot().test(context, node.getUUID())) { addNode(node); } } @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> node) { super.startNodeTraversal(parents, node); final Optional<Edge> dockEdge = node.getInEdges().stream() .filter(e -> e.getContent() instanceof Dock) .findAny(); final Node parent = dockEdge.map(Edge::getSourceNode) .orElseGet(() -> parents.get(parents.size() - 1)); if (dockEdge.isPresent()) { addDockedNode(parent, node); } else if (isCanvasRoot(). test(context, parent.getUUID())) { addNode(node); } else { addChildNode(parent, node); } return true; } private void addNode(final Node node) { if (processedNodes.containsKey(node.getUUID())) { return; } commandBuilder.addCommand(new AddCanvasNodeCommand(node, shapeSetId)); addProcessedNode(node); } private void addChildNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (processedNodes.containsKey(node.getUUID())) { return; } if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasChildNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addDockedNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasDockedNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addProcessedNode(Node<View, Edge> node) { processedNodes.put(node.getUUID(), true); } @Override public void endGraphTraversal() { super.endGraphTraversal(); processedNodes.clear(); processedNodes = null; } }); viewTraverseProcessor .traverse(graph, new AbstractContentTraverseCallback<View<?>, Node<View, Edge>, Edge<View<?>, Node>>() { @Override public void startEdgeTraversal(final Edge<View<?>, Node> edge) { super.startEdgeTraversal(edge); commandBuilder.addCommand(new AddCanvasConnectorCommand(edge, shapeSetId)); } }); return executeCommands(context, commandBuilder); } DrawCanvasCommand(final ChildrenTraverseProcessor childrenTraverseProcessor,
final ViewTraverseProcessor viewTraverseProcessor); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void execute() { tested.execute(context); verify(tested).executeCommands(eq(context), commandsCapture.capture()); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commands = commandsCapture.getValue(); assertEquals(commands.size(), 7); final List<Command<AbstractCanvasHandler, CanvasViolation>> commandList = new ArrayList<>(); for (int i = 0; i < commands.size(); i++) { Command<AbstractCanvasHandler, CanvasViolation> cmd = commands.get(i); commandList.add(cmd); } assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasNodeCommand).count(), 1); assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasChildNodeCommand).count(), 3); assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasDockedNodeCommand).count(), 1); assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasConnectorCommand).count(), 2); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }
|
@Test public void testNewGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> graphCommand = cloneNodeCommand.newGraphCommand(canvasHandler); assertTrue(graphCommand instanceof org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }
|
@Test public void testNewCanvasCommand() { Command<AbstractCanvasHandler, CanvasViolation> canvasCommand = cloneNodeCommand.newCanvasCommand(canvasHandler); assertTrue(canvasCommand instanceof CompositeCommand); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getChild(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(0)).register(anyString(), eq(candidate)); verify(canvasHandler, times(0)).addChild(any(Node.class), any(Node.class)); verify(canvasHandler, times(1)).undock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
@Test @SuppressWarnings("unchecked") public void testExecuteButCandidateHasBeenRemoved() { when(graphIndex.getNode(eq(C_ID))).thenReturn(null); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(0)).register(anyString(), eq(candidate)); verify(canvasHandler, times(0)).addChild(any(Node.class), any(Node.class)); verify(canvasHandler, times(1)).undock(eq(parent), eq(candidate)); verify(canvasHandler, never()).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testChecks() { tested = new DeleteCanvasControlPointCommand(edge, 0); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new DeleteCanvasControlPointCommand(edge, 1); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new DeleteCanvasControlPointCommand(edge, 2); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidIndex() { tested = new DeleteCanvasControlPointCommand(edge, -1); tested.allow(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testIndexForbidden() { tested = new DeleteCanvasControlPointCommand(edge, 3); tested.allow(canvasHandler); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidIndexDuringExecute() { tested = new DeleteCanvasControlPointCommand(edge, -1); tested.execute(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testIndexForbiddenDuringExecute() { tested = new DeleteCanvasControlPointCommand(edge, 3); tested.execute(canvasHandler); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test public void testRemoveOnClosedByKeyboardCallback() { final PopupEditorControls editor = mock(PopupEditorControls.class, withSettings().extraInterfaces(CanBeClosedByKeyboard.class)); view.removeOnClosedByKeyboardCallback(editor); verify((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); }
|
UpdateCanvasControlPointPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkUpdateControlPoint(getControlPoints(edge), controlPoints); return CanvasCommandResultBuilder.SUCCESS; } UpdateCanvasControlPointPositionCommand(final Edge edge,
final ControlPoint[] controlPoints); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testCheck() { tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPs() { newControlPoints = new ControlPoint[]{newControlPoint1, newControlPoint2}; tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); tested.allow(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPs2() { viewConnector.setControlPoints(new ControlPoint[]{controlPoint1, controlPoint2}); tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); tested.allow(canvasHandler); }
|
UpdateCanvasControlPointPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, edge, view -> view.updateControlPoints(controlPoints)); return buildResult(); } UpdateCanvasControlPointPositionCommand(final Edge edge,
final ControlPoint[] controlPoints); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPsDuringExecute() { newControlPoints = new ControlPoint[]{newControlPoint1, newControlPoint2}; tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); tested.execute(canvasHandler); }
@Test public void execute() { checkExecution(true); }
|
RemoveCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { children.forEach(child -> { context.removeChild(parent, child); moveViewConnectorsToTop(context, child); }); return buildResult(); } RemoveCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> children); RemoveCanvasChildrenCommand(final Node parent,
final Node<?, Edge> child); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getChildren(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).removeChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(connectorShapeView1, times(1)).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, times(1)).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); }
|
BaseCanvasHandler extends AbstractCanvasHandler<D, C> { @Override @SuppressWarnings("unchecked") public void applyElementMutation(final Shape shape, final Element candidate, final boolean applyPosition, final boolean applyProperties, final MutationContext mutationContext) { if (shape instanceof ElementShape) { final ElementShape graphShape = (ElementShape) shape; this.applyElementMutation(graphShape, candidate, applyPosition, applyProperties, mutationContext); } else { LOGGER.log(Level.WARNING, "The shape to handle must be type of [" + ElementShape.class.getName() + "]"); } } BaseCanvasHandler(final DefinitionManager definitionManager,
final GraphUtils graphUtils,
final ShapeManager shapeManager,
final TextPropertyProviderFactory textPropertyProviderFactory); abstract void draw(ParameterizedCommand<CommandResult> loadCallback); @Override CanvasHandler<D, C> handle(final C canvas); @Override @SuppressWarnings("unchecked") void draw(final D diagram,
final ParameterizedCommand<CommandResult> loadCallback); @Override RuleSet getRuleSet(); @Override C getCanvas(); @Override D getDiagram(); @Override @SuppressWarnings("unchecked") ShapeFactory<Object, Shape> getShapeFactory(final String shapeSetId); @Override void register(final Shape shape,
final Element<View<?>> candidate,
final boolean fireEvents); @Override void deregister(final Shape shape,
final Element element,
final boolean fireEvents); void addShape(final Shape shape); void removeShape(final Shape shape); @Override @SuppressWarnings("unchecked") void applyElementMutation(final Shape shape,
final Element candidate,
final boolean applyPosition,
final boolean applyProperties,
final MutationContext mutationContext); @Override @SuppressWarnings("unchecked") void addChild(final Element parent,
final Element child); @Override void addChild(final Element parent,
final Element child,
final int index); @Override @SuppressWarnings("unchecked") void removeChild(final Element parent,
final Element child); @Override @SuppressWarnings("unchecked") Optional<Element> getElementAt(final double x,
final double y); @Override boolean dock(final Element parent,
final Element child); @Override @SuppressWarnings("unchecked") void undock(final Element target,
final Element child); @Override CanvasHandler<D, C> doClear(); @Override void doDestroy(); @Override DefinitionManager getDefinitionManager(); @Override TextPropertyProviderFactory getTextPropertyProviderFactory(); GraphUtils getGraphUtils(); ShapeManager getShapeManager(); }
|
@Test public void checkApplyElementMutationOnPosition() { final ElementShape shape = mock(ElementShape.class); final Element candidate = mock(Element.class); final boolean applyPosition = true; final boolean applyProperties = false; final MutationContext mutationContext = mock(MutationContext.class); canvasHandler.applyElementMutation(shape, candidate, applyPosition, applyProperties, mutationContext); verify(shape, atLeastOnce()).applyPosition(any(), any()); verify(canvasElementUpdatedEvent, atLeastOnce()).fire(any()); }
@Test public void checkApplyElementMutationNotifyQueued() { canvasHandler.setStaticContext(queueGraphExecutionContext); final ElementShape shape = mock(ElementShape.class); final Element candidate = mock(Element.class); final boolean applyPosition = true; final boolean applyProperties = false; final MutationContext mutationContext = mock(MutationContext.class); canvasHandler.applyElementMutation(shape, candidate, applyPosition, applyProperties, mutationContext); verify(shape, atLeastOnce()).applyPosition(any(), any()); verify(canvasElementUpdatedEvent, atLeastOnce()).fire(any()); verify(queueGraphExecutionContext, times(1)).addElement(candidate); }
@Test public void checkApplyElementMutationNullQueue() { canvasHandler.setStaticContext(null); final ElementShape shape = mock(ElementShape.class); final Element candidate = mock(Element.class); final boolean applyPosition = true; final boolean applyProperties = false; final MutationContext mutationContext = mock(MutationContext.class); canvasHandler.applyElementMutation(shape, candidate, applyPosition, applyProperties, mutationContext); verify(shape, atLeastOnce()).applyPosition(any(), any()); verify(canvasElementUpdatedEvent, atLeastOnce()).fire(any()); verify(queueGraphExecutionContext, never()).addElement(candidate); }
@Test public void checkNotifyElementUpdatedOnNonQueuedContext() { canvasHandler.addRegistrationListener(updateListener); canvasHandler.setStaticContext(contextualGraphExecutionContext); final ElementShape shape = mock(ElementShape.class); final Element candidate = mock(Element.class); final boolean applyPosition = true; final boolean applyProperties = false; final MutationContext mutationContext = mock(MutationContext.class); canvasHandler.applyElementMutation(shape, candidate, applyPosition, applyProperties, mutationContext); verify(shape, atLeastOnce()).applyPosition(any(), any()); verify(canvasElementUpdatedEvent, atLeastOnce()).fire(any()); verify(queueGraphExecutionContext, never()).addElement(candidate); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void focusOnDMNContainer(final Object o) { final Element element = getDMNContainer(); if (!Objects.isNull(element)) { element.focus(); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test public void testFocusOnDMNContainer() { final elemental2.dom.Element dmnContainerElement = mock(elemental2.dom.Element.class); doReturn(dmnContainerElement).when(view).getDMNContainer(); view.focusOnDMNContainer(null); verify(dmnContainerElement).focus(); }
|
TransformImpl implements Transform { @Override public Point2D getTranslate() { return translate; } TransformImpl(final Point2D translate, final Point2D scale); @Override Point2D getTranslate(); @Override Point2D getScale(); @Override Point2D transform(final double x, final double y); @Override Point2D inverse(final double x, final double y); static final TransformImpl NO_TRANSFORM; }
|
@Test public void testGetTranslate() { final Point2D t = tested.getTranslate(); assertEquals(translate, t); }
|
TransformImpl implements Transform { @Override public Point2D getScale() { return scale; } TransformImpl(final Point2D translate, final Point2D scale); @Override Point2D getTranslate(); @Override Point2D getScale(); @Override Point2D transform(final double x, final double y); @Override Point2D inverse(final double x, final double y); static final TransformImpl NO_TRANSFORM; }
|
@Test public void testGetScale() { final Point2D s = tested.getScale(); assertEquals(scale, s); }
|
TransformImpl implements Transform { @Override public Point2D transform(final double x, final double y) { return new Point2D((x * scale.getX()) + translate.getX(), (y * scale.getY()) + translate.getY()); } TransformImpl(final Point2D translate, final Point2D scale); @Override Point2D getTranslate(); @Override Point2D getScale(); @Override Point2D transform(final double x, final double y); @Override Point2D inverse(final double x, final double y); static final TransformImpl NO_TRANSFORM; }
|
@Test public void testTransform() { final Point2D t = tested.transform(1, 1); assertEquals(12, t.getX(), 0); assertEquals(25, t.getY(), 0); final Point2D t1 = tested.transform(2, 2); assertEquals(14, t1.getX(), 0); assertEquals(30, t1.getY(), 0); }
|
ScreenEventPublisher { protected void onPlaceMaximizedEvent(@Observes PlaceMaximizedEvent event) { diagramEditorMaximizedEventEvent.fire(new ScreenMaximizedEvent(verifyEventIdentifier(event))); } @Inject ScreenEventPublisher(Event<ScreenMaximizedEvent> diagramEditorMaximizedEventEvent,
Event<ScreenMinimizedEvent> diagramEditorMinimizedEventEvent,
ActivityBeansCache activityBeansCache); }
|
@Test public void onPlaceMaximizedEventTest() { screenEventPublisher.onPlaceMaximizedEvent(placeMaximizedEvent); verify(diagramEditorMaximizedEventEvent, Mockito.times(1)).fire(new ScreenMaximizedEvent(true)); reset(syncBeanDef); screenEventPublisher.onPlaceMaximizedEvent(placeMaximizedEvent); verify(diagramEditorMaximizedEventEvent, Mockito.times(1)).fire(new ScreenMaximizedEvent(false)); }
|
ScreenEventPublisher { protected void onPlaceMinimizedEvent(@Observes PlaceMinimizedEvent event) { diagramEditorMinimizedEventEvent.fire(new ScreenMinimizedEvent(verifyEventIdentifier(event))); } @Inject ScreenEventPublisher(Event<ScreenMaximizedEvent> diagramEditorMaximizedEventEvent,
Event<ScreenMinimizedEvent> diagramEditorMinimizedEventEvent,
ActivityBeansCache activityBeansCache); }
|
@Test public void onPlaceMinimizedEventTest() { screenEventPublisher.onPlaceMinimizedEvent(placeMinimizedEvent); verify(diagramEditorMinimizedEventEvent, Mockito.times(1)).fire(new ScreenMinimizedEvent(true)); reset(syncBeanDef); screenEventPublisher.onPlaceMinimizedEvent(placeMinimizedEvent); verify(diagramEditorMinimizedEventEvent, Mockito.times(1)).fire(new ScreenMinimizedEvent(false)); }
|
BindableShapeSetThumbProvider implements ShapeSetThumbProvider { protected boolean isSameClass(final Class<?> c1, final Class<?> c2) { return Objects.equals(c1, c2); } BindableShapeSetThumbProvider(final DefinitionManager definitionManager); @Override Class<String> getSourceType(); @Override boolean thumbFor(final String definitionSetId); }
|
@Test public void testIsSameClass() { BindableShapeSetThumbProvider provider = new StubProvider(definitionManager); BindableShapeSetThumbProvider sameProvider = new StubProvider(definitionManager2); assertTrue(provider.isSameClass(provider.getClass(), provider.getClass())); assertTrue(provider.isSameClass(provider.getClass(), sameProvider.getClass())); assertTrue(provider.isSameClass(sameProvider.getClass(), provider.getClass())); assertFalse(provider.isSameClass(null, provider.getClass())); assertFalse(provider.isSameClass(provider.getClass(), null)); assertFalse(provider.isSameClass(provider.getClass(), Object.class)); assertFalse(provider.isSameClass(Object.class, provider.getClass())); }
|
BackendTranslationService extends AbstractTranslationService { @Override public String getValue(String key) { return key; } @Override String getValue(String key); @Override String getValue(String key, Object... args); @Override Optional<String> getElementName(String uuid); }
|
@Test public void testGetValue() { assertEquals("key1", tested.getValue("key1")); }
@Test public void testGetValueWithArgs() { assertEquals("key1[arg1, arg2]", tested.getValue("key1", "arg1", "arg2")); }
|
BackendTranslationService extends AbstractTranslationService { @Override public Optional<String> getElementName(String uuid) { return Optional.of(uuid); } @Override String getValue(String key); @Override String getValue(String key, Object... args); @Override Optional<String> getElementName(String uuid); }
|
@Test public void testGetElementName() { assertTrue(tested.getElementName("element1").isPresent()); assertEquals("element1", tested.getElementName("element1").get()); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void hide() { getActiveEditor().ifPresent(PopupEditorControls::hide); getActiveEditor().ifPresent(e -> removeOnClosedByKeyboardCallback(e)); setActiveEditor(Optional.empty()); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test public void testHide() { final PopupEditorControls editor = mock(PopupEditorControls.class); final Optional<PopupEditorControls> activeEditor = Optional.of(editor); doReturn(activeEditor).when(view).getActiveEditor(); view.hide(); verify(editor).hide(); verify(view).removeOnClosedByKeyboardCallback(editor); verify(view).setActiveEditor(Optional.empty()); }
|
URLUtils { public static String buildDataURIFromStream(final String fileName, final InputStream inputStream) throws Exception { final ByteArrayOutputStream os = new ByteArrayOutputStream(); final String contentType = guessContentType(fileName, inputStream); if (null != contentType) { final byte[] chunk = new byte[4096]; int bytesRead; while ((bytesRead = inputStream.read(chunk)) > 0) { os.write(chunk, 0, bytesRead); } os.flush(); inputStream.close(); return "data:" + contentType + ";base64," + Base64.getEncoder().encodeToString(os.toByteArray()); } else { throw new UnsupportedOperationException("Content type is undefined."); } } static byte[] readBytesFromURL(final String uri); static byte[] readBytes(final InputStream is); static String readFromURL(final String uri); static String readFromURL(final URL url); static String buildDataURIFromURL(final String url); static String buildDataURIFromURL(final URL url); static String buildDataURIFromStream(final String fileName,
final InputStream inputStream); static String guessContentType(final String fileName,
final InputStream stream); }
|
@Test public void buildImageDataUriTest() throws Exception { String dataUri = URLUtils.buildDataURIFromStream("email.gif", loadStream(IMAGE_PATH)); assertEquals(IMAGE_DATA_URI, dataUri); }
|
AbstractVFSDiagramService implements BaseDiagramService<M, D> { public Path create(final Path path, final String name, final String defSetId, final Metadata metadata) { final DefinitionSetService services = getServiceById(defSetId); if (null == services) { throw new IllegalStateException("No backend Definition Set services for [" + defSetId + "]"); } final String fName = buildFileName(name, services.getResourceType()); final org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(fName); if (getIoService().exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } try { final D diagram = factoryManager.newDiagram(name, defSetId, metadata); final String[] raw = serialize(diagram); getIoService().write(kiePath, raw[0], new CommentedOption(identity.getIdentifier())); return Paths.convert(kiePath); } catch (final Exception e) { LOG.error("Cannot create diagram in path [" + kiePath + "]", e); } return null; } AbstractVFSDiagramService(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final User identity); Path create(final Path path,
final String name,
final String defSetId,
final Metadata metadata); @Override String getRawContent(D diagram); @SuppressWarnings("unchecked") D getDiagramByPath(final org.uberfire.backend.vfs.Path file); M saveOrUpdate(final D diagram); @Override Path saveOrUpdateSvg(Path diagramPath, String rawDiagramSvg); boolean delete(final D diagram); boolean contains(final D item); Collection<D> getDiagramsByPath(final org.uberfire.java.nio.file.Path root); boolean accepts(final org.uberfire.backend.vfs.Path path); static final String SVG_SUFFIX; }
|
@Test public void testCreate() throws IOException { Path path = mock(Path.class); when(path.toURI()).thenReturn(DIR_URI); final org.uberfire.java.nio.file.Path expectedNioPath = Paths.convert(path).resolve(FILE_NAME_IN_RESOURCE_FORMAT); when(factoryManager.newDiagram(FILE_NAME, DEFINITION_SET_ID, metadata)).thenReturn(diagram); diagramService.create(path, FILE_NAME, DEFINITION_SET_ID, metadata); verify(ioService, times(1)).write(eq(expectedNioPath), eq(DIAGRAM_MARSHALLED), any(CommentedOption.class)); }
|
AbstractVFSDiagramService implements BaseDiagramService<M, D> { @Override public String getRawContent(D diagram) { try { return serialize(diagram)[0]; } catch (java.io.IOException e) { LOG.error("Error while getting raw content for diagram with UUID [" + diagram.getName() + "].", e); throw new RuntimeException(e); } } AbstractVFSDiagramService(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final User identity); Path create(final Path path,
final String name,
final String defSetId,
final Metadata metadata); @Override String getRawContent(D diagram); @SuppressWarnings("unchecked") D getDiagramByPath(final org.uberfire.backend.vfs.Path file); M saveOrUpdate(final D diagram); @Override Path saveOrUpdateSvg(Path diagramPath, String rawDiagramSvg); boolean delete(final D diagram); boolean contains(final D item); Collection<D> getDiagramsByPath(final org.uberfire.java.nio.file.Path root); boolean accepts(final org.uberfire.backend.vfs.Path path); static final String SVG_SUFFIX; }
|
@Test public void testGetRawContent() throws IOException { String result = diagramService.getRawContent(diagram); assertEquals(DIAGRAM_MARSHALLED, result); }
|
AbstractVFSDiagramService implements BaseDiagramService<M, D> { @SuppressWarnings("unchecked") public D getDiagramByPath(final org.uberfire.backend.vfs.Path file) { if (accepts(file)) { DefinitionSetService services = getServiceByPath(file); if (null != services) { final String defSetId = getDefinitionSetId(services); final String name = parseFileName(file, services); final M metadata = (M) buildMetadataInstance(file, defSetId, name); metadata.setPath(file); final InputStream is = loadPath(file); try { final MarshallingResponse<Graph<DefinitionSet, ?>> marshallingResponse = services.getDiagramMarshaller().unmarshallWithValidation(MarshallingRequest.builder() .metadata(metadata) .input(is) .mode(MarshallingRequest.Mode.AUTO) .build()); final Graph<DefinitionSet, ?> graph = Optional.ofNullable(marshallingResponse.getResult()) .orElseThrow(() -> new RuntimeException(marshallingResponse.getMessages().toString())); final DiagramFactory<M, ?> factory = factoryManager.registry().getDiagramFactory(graph.getContent().getDefinition(), getMetadataType()); return (D) factory.build(name, metadata, graph); } catch (Exception e) { LOG.error("Cannot unmarshall diagram for diagram's path [" + file + "]", e); final String xml = getIoService().readAllString(Paths.convert(file)); throw new DiagramParsingException(metadata, xml); } } } throw new UnsupportedOperationException("Diagram format not supported [" + file + "]"); } AbstractVFSDiagramService(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final User identity); Path create(final Path path,
final String name,
final String defSetId,
final Metadata metadata); @Override String getRawContent(D diagram); @SuppressWarnings("unchecked") D getDiagramByPath(final org.uberfire.backend.vfs.Path file); M saveOrUpdate(final D diagram); @Override Path saveOrUpdateSvg(Path diagramPath, String rawDiagramSvg); boolean delete(final D diagram); boolean contains(final D item); Collection<D> getDiagramsByPath(final org.uberfire.java.nio.file.Path root); boolean accepts(final org.uberfire.backend.vfs.Path path); static final String SVG_SUFFIX; }
|
@Test public void testGetDiagramByPath() throws IOException { final Path path = mockGetDiagramByPathObjects(); Diagram result = diagramService.getDiagramByPath(path); assertEquals(diagram, result); }
@Test @SuppressWarnings("unchecked") public void testGetDiagramByPathParseException() throws IOException { final String processDefinition = "broken DEFINITION"; final Path path = mockGetDiagramByPathObjects(); when(ioService.readAllString(Paths.convert(path))).thenReturn(processDefinition); try { Mockito.when(diagramMarshaller.unmarshallWithValidation(anyObject())) .thenReturn(MarshallingResponse.builder() .state(MarshallingResponse.State.ERROR) .addMessage(MarshallingMessage.builder().message("error").build()) .build()); diagramService.getDiagramByPath(path); } catch (DiagramParsingException dpe) { assertEquals(processDefinition, dpe.getXml()); assertNotNull(dpe.getMetadata()); } catch (Exception e) { fail("Exception should have been caught and wrapped as DiagramParsingException"); } }
|
AbstractVFSDiagramService implements BaseDiagramService<M, D> { public boolean contains(final D item) { return null != getDiagramByPath(item.getMetadata().getPath()); } AbstractVFSDiagramService(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final User identity); Path create(final Path path,
final String name,
final String defSetId,
final Metadata metadata); @Override String getRawContent(D diagram); @SuppressWarnings("unchecked") D getDiagramByPath(final org.uberfire.backend.vfs.Path file); M saveOrUpdate(final D diagram); @Override Path saveOrUpdateSvg(Path diagramPath, String rawDiagramSvg); boolean delete(final D diagram); boolean contains(final D item); Collection<D> getDiagramsByPath(final org.uberfire.java.nio.file.Path root); boolean accepts(final org.uberfire.backend.vfs.Path path); static final String SVG_SUFFIX; }
|
@Test public void testContains() { Path path = mock(Path.class); when(metadata.getPath()).thenReturn(path); doReturn(diagram).when(diagramService).getDiagramByPath(path); assertTrue(diagramService.contains(diagram)); verify(diagramService, times(1)).getDiagramByPath(path); }
|
BackendFileSystemManager { public void deploy(final org.uberfire.java.nio.file.Path global, final Assets assets, final String message) { if (!ioService.exists(global)) { ioService.createDirectories(global); } try { ioService.startBatch(global.getFileSystem()); for (final Asset asset : assets.assets) { final org.uberfire.java.nio.file.Path assetPath = global.resolve(asset.fileName); final InputStream resource = asset.stream; final ByteArrayOutputStream os = new ByteArrayOutputStream(); final byte[] chunk = new byte[4096]; int bytesRead; while ((bytesRead = resource.read(chunk)) > 0) { os.write(chunk, 0, bytesRead); } os.flush(); resource.close(); ioService.write(assetPath, os.toByteArray(), optionFactory.makeCommentedOption(message)); } } catch (final Exception e) { LOG.error("Error while deploying assets.", e); } finally { ioService.endBatch(); } } protected BackendFileSystemManager(); @Inject BackendFileSystemManager(final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory optionFactory); void deploy(final org.uberfire.java.nio.file.Path global,
final Assets assets,
final String message); String getPathRelativeToApp(final String path); void findAndDeployFiles(final File directory,
final org.uberfire.java.nio.file.Path targetPath); void findAndDeployFiles(final File directory,
final FilenameFilter filter,
final org.uberfire.java.nio.file.Path targetPath); IOService getIoService(); static final Charset UT8; static final String UT8_ENC; }
|
@Test public void testDeployAssets() throws Exception { final org.uberfire.java.nio.file.Path asset1Path = mock(org.uberfire.java.nio.file.Path.class); final org.uberfire.java.nio.file.Path asset2Path = mock(org.uberfire.java.nio.file.Path.class); when(path.resolve(eq(ASSET1_NAME))).thenReturn(asset1Path); when(path.resolve(eq(ASSET2_NAME))).thenReturn(asset2Path); when(ioService.exists(eq(path))).thenReturn(false); final String message = "deploy-message"; final ArgumentCaptor<byte[]> bytesCaptor1 = ArgumentCaptor.forClass(byte[].class); final ArgumentCaptor<byte[]> bytesCaptor2 = ArgumentCaptor.forClass(byte[].class); tested.deploy(path, new BackendFileSystemManager.Assets(Arrays.asList(asset1, asset2)), message); verify(ioService, times(1)).createDirectories(eq(path)); verify(ioService, times(1)).startBatch(eq(fileSystem)); verify(ioService, times(1)).write(eq(asset1Path), bytesCaptor1.capture(), any(CommentedOption.class)); verify(ioService, times(1)).write(eq(asset2Path), bytesCaptor2.capture(), any(CommentedOption.class)); verify(optionFactory, times(2)).makeCommentedOption(eq(message)); verify(ioService, times(1)).endBatch(); final byte[] bytes1 = bytesCaptor1.getValue(); final String expectedContent1 = new String(bytes1, BackendFileSystemManager.UT8); Assert.assertEquals(ASSET1_CONTENT, expectedContent1); final byte[] bytes2 = bytesCaptor2.getValue(); final String expectedContent2 = new String(bytes2, BackendFileSystemManager.UT8); Assert.assertEquals(ASSET2_CONTENT, expectedContent2); }
|
XMLEncoderDiagramMetadataMarshaller implements DiagramMetadataMarshaller<Metadata> { @Override public String marshall(final Metadata metadata) throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); XMLEncoder encoder = new XMLEncoder(os); encoder.writeObject(metadata); encoder.close(); String raw = os.toString(CHARSET); return raw; } @Override Metadata unmarshall(final InputStream input); @Override String marshall(final Metadata metadata); }
|
@Test public void testEncode() throws Exception { MetadataImpl metadata = new MetadataImpl.MetadataImplBuilder("defSet1").build(); metadata.setTitle("title1"); metadata.setCanvasRootUUID("root1"); metadata.setShapeSetId("ss1"); metadata.setThumbData("thumbData1"); metadata.setTitle("title1"); String result = tested.marshall(metadata); assertNotNull(result); assertFalse(result.isEmpty()); assertTrue(result.contains("<java")); assertTrue(result.contains("</java>")); }
|
XMLEncoderDiagramMetadataMarshaller implements DiagramMetadataMarshaller<Metadata> { @Override public Metadata unmarshall(final InputStream input) throws IOException { try (final XMLDecoder decoder = new XMLDecoder(input)) { return (Metadata) decoder.readObject(); } } @Override Metadata unmarshall(final InputStream input); @Override String marshall(final Metadata metadata); }
|
@Test public void testDecodeTest1() throws Exception { InputStream is = loadStream(TEST1); Metadata metadata = tested.unmarshall(is); assertNotNull(metadata); assertEquals("defSet1", metadata.getDefinitionSetId()); assertEquals("ss1", metadata.getShapeSetId()); assertEquals("thumbData1", metadata.getThumbData()); assertEquals("title1", metadata.getTitle()); assertEquals("root1", metadata.getCanvasRootUUID()); }
|
BackendRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected BackendRuleManager(); @Inject BackendRuleManager(final CachedRuleManager ruleManager,
final @Any Instance<RuleEvaluationHandler<? extends Rule, ?>> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testGetRegistry() { assertEquals(registry, tested.registry()); }
|
CellEditorControlImpl extends AbstractCanvasControl<AbstractCanvas> implements CellEditorControl { @Override public void bind(final DMNSession session) { this.editorControls.setGridPanelSupplier(Optional.of(session::getGridPanel)); } CellEditorControlImpl(); @Inject CellEditorControlImpl(final CellEditorControls editorControls); @Override void bind(final DMNSession session); @Override CellEditorControls getCellEditorControls(); }
|
@Test public void testBind() { control.bind(session); verify(editorControls).setGridPanelSupplier(gridPanelSupplierArgumentCaptor.capture()); final Optional<Supplier<DMNGridPanel>> gridPanelSupplier = gridPanelSupplierArgumentCaptor.getValue(); assertTrue(gridPanelSupplier.isPresent()); assertEquals(gridPanel, gridPanelSupplier.get().get()); }
|
BackendRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected BackendRuleManager(); @Inject BackendRuleManager(final CachedRuleManager ruleManager,
final @Any Instance<RuleEvaluationHandler<? extends Rule, ?>> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testEvaluate() { RuleSet ruleSet = mock(RuleSet.class); RuleEvaluationContext context = mock(RuleEvaluationContext.class); tested.evaluate(ruleSet, context); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(context)); }
|
BackendProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.forEach(profileInstances::destroy); } @Inject BackendProfileManager(final DefinitionUtils definitionUtils,
final @Any Instance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testDestroy() { tested.destroy(); verify(profileInstances, times(1)).destroy(eq(profile1)); verify(profileInstances, times(1)).destroy(eq(profile2)); }
|
BackendProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject BackendProfileManager(final DefinitionUtils definitionUtils,
final @Any Instance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testGetQualifier() { tested.getQualifier().apply("q1"); verify(definitionUtils, times(1)).getQualifier(eq("q1")); tested.getQualifier().apply("q2"); verify(definitionUtils, times(1)).getQualifier(eq("q2")); }
|
BackendProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject BackendProfileManager(final DefinitionUtils definitionUtils,
final @Any Instance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testGetAllProfileInstances() { Iterable<Profile> profiles = tested.getAllProfileInstances(); Iterator<Profile> iterator = profiles.iterator(); assertEquals(profile1, iterator.next()); assertEquals(profile2, iterator.next()); assertFalse(iterator.hasNext()); }
|
BackendProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } @Inject BackendProfileManager(final DefinitionUtils definitionUtils,
final @Any Instance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testSelectProfileInstances() { Annotation qualifier = mock(Annotation.class); tested.selectProfileInstances(qualifier); verify(profileInstances, times(1)).select(eq(qualifier)); }
|
BackendPropertyAdapter extends AbstractReflectAdapter<T> implements PropertyAdapter<T, Object> { @Override public String getId(final T property) { return BindableAdapterUtils.getPropertyId(property.getClass()); } @Override String getId(final T property); @Override String getCaption(final T property); @Override Object getValue(final T property); @Override void setValue(final T property,
final Object value); @Override boolean accepts(final Class<?> pojo); }
|
@Test public void testGetId() { final String id = tested.getId(instance); assertEquals(FooProperty1TestBean.class.getName(), id); }
|
BackendPropertyAdapter extends AbstractReflectAdapter<T> implements PropertyAdapter<T, Object> { @Override public String getCaption(final T property) { try { return getAnnotatedFieldValue(property, Caption.class); } catch (Exception e) { LOG.error("Error obtaining annotated category for Property with id " + getId(property)); } return null; } @Override String getId(final T property); @Override String getCaption(final T property); @Override Object getValue(final T property); @Override void setValue(final T property,
final Object value); @Override boolean accepts(final Class<?> pojo); }
|
@Test public void testGetCaption() { final String title = tested.getCaption(instance); assertEquals(FooProperty1TestBean.CAPTION, title); }
|
BackendPropertyAdapter extends AbstractReflectAdapter<T> implements PropertyAdapter<T, Object> { @Override public Object getValue(final T property) { if (null != property) { Class<?> c = property.getClass(); while (!(c.isAssignableFrom(Object.class))) { Field[] fields = c.getDeclaredFields(); for (Field field : fields) { Value annotation = field.getAnnotation(Value.class); if (null != annotation) { try { return _getValue(field, annotation, property); } catch (Exception e) { LOG.error("Error obtaining annotated value for Property with id " + getId(property), e); } } } c = c.getSuperclass(); } } return null; } @Override String getId(final T property); @Override String getCaption(final T property); @Override Object getValue(final T property); @Override void setValue(final T property,
final Object value); @Override boolean accepts(final Class<?> pojo); }
|
@Test public void testGetValue() { final Object value = tested.getValue(instance); assertEquals(FOO1_VALUE, value); }
|
BackendPropertyAdapter extends AbstractReflectAdapter<T> implements PropertyAdapter<T, Object> { @Override public void setValue(final T property, final Object value) { if (null != property) { Class<?> c = property.getClass(); boolean done = false; while (!done && !(c.isAssignableFrom(Object.class))) { Field[] fields = c.getDeclaredFields(); for (Field field : fields) { Value annotation = field.getAnnotation(Value.class); if (null != annotation) { try { field.setAccessible(true); field.set(property, value); done = true; break; } catch (Exception e) { LOG.error("Error setting value for Property with id [" + getId(property) + "] " + "and value [" + (value != null ? value.toString() : "null") + "]"); } } } c = c.getSuperclass(); } } } @Override String getId(final T property); @Override String getCaption(final T property); @Override Object getValue(final T property); @Override void setValue(final T property,
final Object value); @Override boolean accepts(final Class<?> pojo); }
|
@Test public void testSetValue() { tested.setValue(instance, "someNewValue"); final Object value = tested.getValue(instance); assertEquals("someNewValue", value); }
|
BackendDefinitionSetAdapter extends AbstractReflectDefinitionSetAdapter<T> implements DefinitionSetAdapter<T> { @Override public String getDescription(final T definitionSet) { try { return getAnnotatedFieldValue(definitionSet, Description.class); } catch (Exception e) { LOG.error("Error obtaining annotated category for DefinitionSet with id " + getId(definitionSet)); } return BindableAdapterUtils.toSimpleName(definitionSet); } @Inject BackendDefinitionSetAdapter(final BackendDefinitionAdapter annotatedDefinitionAdapter); @Override boolean accepts(final Class<?> pojo); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definitionSet); @Override Annotation getQualifier(final T definitionSet); @Override String getDescription(final T definitionSet); @Override Set<String> getDefinitions(final T definitionSet); }
|
@Test public void testGetDescription() { final String description = tested.getDescription(instance); assertEquals(FooTestSet.DESC, description); }
|
CellEditorControlImpl extends AbstractCanvasControl<AbstractCanvas> implements CellEditorControl { @Override protected void doDestroy() { this.editorControls.setGridPanelSupplier(Optional.empty()); } CellEditorControlImpl(); @Inject CellEditorControlImpl(final CellEditorControls editorControls); @Override void bind(final DMNSession session); @Override CellEditorControls getCellEditorControls(); }
|
@Test public void testDoDestroy() { control.bind(session); reset(editorControls); control.doDestroy(); verify(editorControls).setGridPanelSupplier(gridPanelSupplierArgumentCaptor.capture()); final Optional<Supplier<DMNGridPanel>> gridPanelSupplier = gridPanelSupplierArgumentCaptor.getValue(); assertFalse(gridPanelSupplier.isPresent()); }
|
BackendDefinitionSetAdapter extends AbstractReflectDefinitionSetAdapter<T> implements DefinitionSetAdapter<T> { @Override public Class<? extends ElementFactory> getGraphFactoryType(final T definitionSet) { Class<? extends ElementFactory> result = null; if (null != definitionSet) { DefinitionSet annotation = definitionSet.getClass().getAnnotation(DefinitionSet.class); if (null != annotation) { result = annotation.graphFactory(); } } return result; } @Inject BackendDefinitionSetAdapter(final BackendDefinitionAdapter annotatedDefinitionAdapter); @Override boolean accepts(final Class<?> pojo); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definitionSet); @Override Annotation getQualifier(final T definitionSet); @Override String getDescription(final T definitionSet); @Override Set<String> getDefinitions(final T definitionSet); }
|
@Test public void testGraphFactory() { final Class<? extends ElementFactory> graphFactoryType = tested.getGraphFactoryType(instance); assertEquals(GraphFactory.class, graphFactoryType); }
|
BackendDefinitionSetAdapter extends AbstractReflectDefinitionSetAdapter<T> implements DefinitionSetAdapter<T> { @Override public Set<String> getDefinitions(final T definitionSet) { return getAnnotatedDefinitions(definitionSet); } @Inject BackendDefinitionSetAdapter(final BackendDefinitionAdapter annotatedDefinitionAdapter); @Override boolean accepts(final Class<?> pojo); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definitionSet); @Override Annotation getQualifier(final T definitionSet); @Override String getDescription(final T definitionSet); @Override Set<String> getDefinitions(final T definitionSet); }
|
@Test public void testGetDefinitions() { final Set<String> definitions = tested.getDefinitions(instance); assertEquals(1, definitions.size()); assertEquals(FooTestBean.class.getName(), definitions.iterator().next()); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public DefinitionId getId(final T definition) { final String definitionId = getDefinitionId(definition.getClass()); final Id idAnn = getClassAnnotation(definition.getClass(), Id.class); if (null != idAnn) { try { final String value = BindableAdapterUtils.getDynamicDefinitionId(definitionId, getAnnotatedFieldValue(definition, Id.class)); return DefinitionId.build(value, definitionId.length()); } catch (Exception e) { LOG.error("Error obtaining annotated id for Definition " + definition.getClass().getName()); } } return DefinitionId.build(definitionId); } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGetId() { final String id = tested.getId(instance).value(); assertEquals(FooTestBean.class.getName(), id); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public String getCategory(final T definition) { try { return getAnnotatedFieldValue(definition, Category.class); } catch (Exception e) { LOG.error("Error obtaining annotated category for Definition with id " + getId(definition)); } return null; } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGetCategory() { final String category = tested.getCategory(instance); assertEquals(FooTestBean.CATEGORY, category); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public String getTitle(final T definition) { try { return getAnnotatedFieldValue(definition, Title.class); } catch (Exception e) { LOG.error("Error obtaining annotated title for Definition with id " + getId(definition)); } return BindableAdapterUtils.toSimpleName(definition); } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGetTitle() { final String title = tested.getTitle(instance); assertEquals(FooTestBean.TITLE, title); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public String getDescription(final T definition) { try { return getAnnotatedFieldValue(definition, Description.class); } catch (Exception e) { LOG.error("Error obtaining annotated description for Definition with id " + getId(definition)); } return BindableAdapterUtils.toSimpleName(definition); } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGetDescription() { final String description = tested.getDescription(instance); assertEquals(FooTestBean.DESCRIPTION, description); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override @SuppressWarnings("all") public String[] getLabels(final T definition) { try { Object value = getAnnotatedFieldValue(definition, Labels.class); if (value instanceof Collection) { return (String[]) ((Collection) value).toArray(new String[((Collection) value).size()]); } return null != value ? (String[]) value : new String[0]; } catch (Exception e) { LOG.error("Error obtaining annotated labels for Definition with id " + getId(definition)); } return new String[0]; } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGetLabels() { final String[] labels = tested.getLabels(instance); assertArrayEquals(FooTestBean.LABELS.toArray(), labels); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public Class<? extends ElementFactory> getGraphFactoryType(final T definition) { Definition annotation = getDefinitionAnnotation(definition.getClass()); return null != annotation ? annotation.graphFactory() : null; } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGraphFactory() { final Class<? extends ElementFactory> graphFactoryType = tested.getGraphFactoryType(instance); assertEquals(NodeFactory.class, graphFactoryType); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public String getBaseType(final Class<?> type) { return Optional.ofNullable(type) .filter(t -> !t.isPrimitive()) .filter(t -> Objects.nonNull(getClassAnnotation(t, Definition.class))) .map(this::findBaseParent) .map(BackendDefinitionAdapter::getDefinitionId) .orElse(null); } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void baseTypeGrandParentTest() { String baseType = tested.getBaseType(FooTestBeanBaseGrandParent.class); assertEquals(baseType, BaseFooTestBean2.class.getName()); }
@Test public void baseTypeParentTest() { String baseType = tested.getBaseType(FooTestBeanBaseParent.class); assertEquals(baseType, BaseFooTestBean2.class.getName()); }
@Test public void baseTypeNoParentTest() { String baseType = tested.getBaseType(FooTestBeanNoParent.class); assertEquals(baseType, null); }
@Test public void baseTypePrimitiveTest() { String baseType = tested.getBaseType(int.class); assertNull(baseType); baseType = tested.getBaseType(double.class); assertNull(baseType); }
|
KeyboardOperationEscapeGridCell extends BaseKeyboardOperation { @Override public int getKeyCode() { return KeyCodes.KEY_ESCAPE; } KeyboardOperationEscapeGridCell(final GridLayer gridLayer); @Override int getKeyCode(); @Override boolean isExecutable(final GridWidget gridWidget); @Override boolean perform(final GridWidget gridWidget,
final boolean isShiftKeyDown,
final boolean isControlKeyDown); }
|
@Test public void testReactsOnKey() { assertThat(operation.getKeyCode()).isEqualTo(KeyCodes.KEY_ESCAPE); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public String[] getPropertyFields(final T pojo) { final List<String> fields = visitFields(pojo.getClass(), field -> null != field.getAnnotation(Property.class)); return fields.toArray(new String[fields.size()]); } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void testGetProperties() { String[] propertyFields = tested.getPropertyFields(instance); assertEquals(2, propertyFields.length); assertEquals("fooPropertySet.fooProperty", propertyFields[0]); assertEquals("fooProperty", propertyFields[1]); Optional<?> p0 = tested.getProperty(instance, "fooPropertySet.fooProperty"); assertTrue(p0.isPresent()); assertEquals(instance.fooPropertySet.fooProperty, p0.get()); Optional<?> p1 = tested.getProperty(instance, "fooProperty"); assertTrue(p1.isPresent()); assertEquals(instance.fooProperty, p1.get()); }
|
BackendDefinitionAdapter extends AbstractReflectAdapter<T> implements DefinitionAdapter<T>,
HasInheritance { @Override public String getMetaPropertyField(final T pojo, final PropertyMetaTypes metaType) { List<String> fields = visitFields(pojo.getClass(), field -> isPropertyOfMetaType(field, metaType)); return !fields.isEmpty() ? fields.get(0) : null; } @Inject BackendDefinitionAdapter(); @Override boolean accepts(Class<?> pojo); @Override DefinitionId getId(final T definition); @Override String[] getPropertyFields(final T pojo); @Override String getMetaPropertyField(final T pojo,
final PropertyMetaTypes metaType); @Override String getCategory(final T definition); @Override String getTitle(final T definition); @Override String getDescription(final T definition); @Override @SuppressWarnings("all") String[] getLabels(final T definition); @Override Class<? extends ElementFactory> getGraphFactoryType(final T definition); static Class<? extends ElementFactory> getGraphFactory(final Class<?> type); @Override String getBaseType(final Class<?> type); @Override String[] getTypes(final String baseType); }
|
@Test public void getNameField() { String nameField = tested.getMetaPropertyField(instance, PropertyMetaTypes.NAME); assertEquals("fooProperty", nameField); }
|
BackendBindableAdapterFunctions implements BindableAdapterFunctions { @Override public Object getValue(Object property, String fieldName) { return getFieldValue(property, fieldName); } @Override Object getValue(Object property, String fieldName); static Object getFieldValue(Object property, String fieldName); @Override void setValue(Object property, String fieldName, Object value); static void setFieldValue(Object property, String fieldName, Object value); }
|
@Test public void testGetValue() { SomeBean bean = new SomeBean("someString", 5); assertEquals("someString", tested.getValue(bean, "someStringField")); assertEquals(5, tested.getValue(bean, "someIntField")); }
|
BackendBindableAdapterFunctions implements BindableAdapterFunctions { @Override public void setValue(Object property, String fieldName, Object value) { setFieldValue(property, fieldName, value); } @Override Object getValue(Object property, String fieldName); static Object getFieldValue(Object property, String fieldName); @Override void setValue(Object property, String fieldName, Object value); static void setFieldValue(Object property, String fieldName, Object value); }
|
@Test public void testSetValue() { SomeBean bean = new SomeBean("someString", 5); tested.setValue(bean, "someStringField", "anotherString"); tested.setValue(bean, "someIntField", 3); assertEquals("anotherString", bean.someStringField); assertEquals(3, bean.someIntField); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.