src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ExplorerServiceHelper { List<FolderItem> getPathSegments(final Path path) { org.uberfire.java.nio.file.Path nioSegmentPath = Paths.convert(path); final int segmentCount = nioSegmentPath.getNameCount(); if (segmentCount < 1) { return new ArrayList<>(); } final FolderItem[] segments = new FolderItem[segmentCount]; for (int idx = segmentCount; idx > 0; idx--) { nioSegmentPath = nioSegmentPath.getParent(); segments[idx - 1] = toFolderItem(nioSegmentPath); } return Arrays.asList(segments); } ExplorerServiceHelper(); @Inject ExplorerServiceHelper(final KieModuleService moduleService,
final FolderListingResolver folderListingResolver,
@Named("ioStrategy") final IOService ioService,
@Named("configIO") final IOService ioServiceConfig,
final VFSLockServiceImpl lockService,
final MetadataService metadataService,
final UserServicesImpl userServices,
final DeleteService deleteService,
final RenameService renameService,
final CopyService copyService,
@Managed final ExecutorService executorService); FolderItem toFolderItem(final org.guvnor.common.services.project.model.Package pkg); FolderItem toFolderItem(final org.uberfire.java.nio.file.Path path); List<FolderItem> getPackageSegments(final Package _pkg); FolderListing getFolderListing(final FolderItem selectedItem,
final Module selectedModule,
final Package selectedPackage,
final ActiveOptions options); FolderListing getFolderListing(final Package pkg,
final ActiveOptions options); FolderListing getFolderListing(final FolderItem item,
final ActiveOptions options); FolderListing getFolderListing(final Path path,
final ActiveOptions options
); boolean hasAssets(final Package pkg); List<FolderItem> getItems(final Package pkg,
final ActiveOptions options); void store(final WorkspaceProject project,
final Module selectedModule,
final FolderListing folderListing,
final Package selectedPackage,
final ActiveOptions options); void store(final org.uberfire.java.nio.file.Path userNav,
final org.uberfire.java.nio.file.Path lastUserNav,
final WorkspaceProject project,
final Module module,
final Package pkg,
final FolderItem item,
final ActiveOptions options); UserExplorerData loadUserContent(final org.uberfire.java.nio.file.Path path); UserExplorerData loadUserContent(); UserExplorerLastData getLastContent(); UserExplorerLastData getLastContent(final org.uberfire.java.nio.file.Path path); List<FolderItemOperation> getRestrictedOperations(final Path path); }
|
@Test public void getPathSegmentsTest() { doAnswer(invocationOnMock -> { final Path p = Paths.convert((org.uberfire.java.nio.file.Path) invocationOnMock.getArguments()[0]); return new FolderItem(p, p.getFileName(), FolderItemType.FOLDER); }).when(helper).toFolderItem(any(org.uberfire.java.nio.file.Path.class)); Path path = PathFactory.newPath("myproject", "default: final List<FolderItem> pathSegments = helper.getPathSegments(path); assertEquals(5, pathSegments.size()); assertEquals("/", pathSegments.get(0).getFileName()); assertEquals("src", pathSegments.get(1).getFileName()); assertEquals("main", pathSegments.get(2).getFileName()); assertEquals("java", pathSegments.get(3).getFileName()); assertEquals("org", pathSegments.get(4).getFileName()); }
|
PersistenceDescriptorValidationMessageTranslator implements ValidationMessageTranslator { @Override public boolean accept( ValidationMessage checkMessage ) { return checkMessage instanceof PersistenceDescriptorValidationMessage; } @Inject PersistenceDescriptorValidationMessageTranslator( TranslationService translationService ); @Override boolean accept( ValidationMessage checkMessage ); @Override ValidationMessage translate( ValidationMessage checkMessage ); static final String PREFIX; }
|
@Test public void testAcceptMessage( ) { assertTrue( translator.accept( originalMessage ) ); assertFalse( translator.accept( new ValidationMessage( ) ) ); }
|
PersistenceDescriptorValidationMessageTranslator implements ValidationMessageTranslator { @Override public ValidationMessage translate( ValidationMessage checkMessage ) { PersistenceDescriptorValidationMessage pdValidationMessage = ( PersistenceDescriptorValidationMessage ) checkMessage; ValidationMessage result = new ValidationMessage( ); result.setId( checkMessage.getId( ) ); result.setLevel( checkMessage.getLevel( ) ); String translationKey = createTranslationKey( pdValidationMessage.getId( ) ); if ( translationService.getTranslation( translationKey ) != null ) { if ( pdValidationMessage.getParams( ) != null && !pdValidationMessage.getParams( ).isEmpty( ) ) { pdValidationMessage.getParams().toArray( new String[ pdValidationMessage.getParams().size() ] ); result.setText( translationService.format( translationKey, pdValidationMessage.getParams().toArray() ) ); } else { result.setText( translationService.getTranslation( translationKey ) ); } } else { result.setText( checkMessage.getText( ) ); } return result; } @Inject PersistenceDescriptorValidationMessageTranslator( TranslationService translationService ); @Override boolean accept( ValidationMessage checkMessage ); @Override ValidationMessage translate( ValidationMessage checkMessage ); static final String PREFIX; }
|
@Test public void testSimpleTranslation( ) { String translationKey = PersistenceDescriptorValidationMessageTranslator.PREFIX + originalMessage.getId( ); when( translationService.getTranslation( translationKey ) ).thenReturn( TRANSLATED_MESSAGE ); ValidationMessage expectedTranslatedMessage = new ValidationMessage( ); expectedTranslatedMessage.setId( originalMessage.getId( ) ); expectedTranslatedMessage.setLevel( originalMessage.getLevel( ) ); expectedTranslatedMessage.setText( TRANSLATED_MESSAGE ); assertEquals( expectedTranslatedMessage, translator.translate( originalMessage ) ); }
@Test public void testParametrizedTranslation( ) { String translationKey = PersistenceDescriptorValidationMessageTranslator.PREFIX + originalMessage.getId( ); originalMessage.getParams( ).add( "param1" ); originalMessage.getParams( ).add( "param2" ); when( translationService.getTranslation( translationKey ) ).thenReturn( TRANSLATED_MESSAGE ); when( translationService.format( translationKey, originalMessage.getParams( ).toArray( ) ) ).thenReturn( FORMATTED_MESSAGE ); ValidationMessage expectedTranslatedMessage = new ValidationMessage( ); expectedTranslatedMessage.setId( originalMessage.getId( ) ); expectedTranslatedMessage.setLevel( originalMessage.getLevel( ) ); expectedTranslatedMessage.setText( FORMATTED_MESSAGE ); assertEquals( expectedTranslatedMessage, translator.translate( originalMessage ) ); }
|
DroolsDataObjectFieldEditor extends FieldEditor implements DroolsDataObjectFieldEditorView.Presenter { @Override protected void loadDataObjectField( DataObject dataObject, ObjectProperty objectField ) { clear(); setReadonly( true ); if ( dataObject != null && objectField != null ) { this.dataObject = dataObject; this.objectField = objectField; Annotation annotation = objectField.getAnnotation( DroolsDomainAnnotations.KEY_ANNOTATION ); if ( annotation != null ) { view.setEquals( Boolean.TRUE ); } annotation = objectField.getAnnotation( DroolsDomainAnnotations.POSITION_ANNOTATION ); if ( annotation != null ) { Object positionValue = annotation.getValue( DroolsDomainAnnotations.VALUE_PARAM ); String position = positionValue != null ? positionValue.toString() : ""; view.setPosition( position ); } setReadonly( getContext() == null || getContext().isReadonly() ); } } @Inject DroolsDataObjectFieldEditor( DroolsDataObjectFieldEditorView view,
DomainHandlerRegistry handlerRegistry,
Event<DataModelerEvent> dataModelerEvent,
DataModelCommandBuilder commandBuilder ); @Override Widget asWidget(); @Override String getName(); @Override String getDomainName(); void setReadonly( boolean readonly ); @Override void clear(); @Override void onEqualsChange(); @Override void onPositionChange(); }
|
@Test public void loadDataObjectFieldTest() { DroolsDataObjectFieldEditor fieldEditor = createFieldEditor(); DataObject dataObject = context.getDataObject(); ObjectProperty field1 = dataObject.getProperty( "field1" ); context.setObjectProperty( field1 );; fieldEditor.onContextChange( context ); verify( view, times( 1 ) ).setEquals( true ); verify( view, times( 1 ) ).setPosition( "0" ); assertFalse( fieldEditor.isReadonly() ); }
|
DroolsDataObjectEditor extends ObjectEditor implements DroolsDataObjectEditorView.Presenter { protected void loadDataObject( DataObject dataObject ) { clear(); setReadonly( true ); if ( dataObject != null ) { this.dataObject = dataObject; Annotation annotation = dataObject.getAnnotation( DroolsDomainAnnotations.ROLE_ANNOTATION ); if ( annotation != null ) { String value = annotation.getValue( DroolsDomainAnnotations.VALUE_PARAM ) != null ? annotation.getValue( DroolsDomainAnnotations.VALUE_PARAM ).toString() : UIUtil.NOT_SELECTED; view.setRole( value ); } annotation = dataObject.getAnnotation( DroolsDomainAnnotations.PROPERTY_REACTIVE_ANNOTATION ); if ( annotation != null ) { view.setPropertyReactive( Boolean.TRUE ); } annotation = dataObject.getAnnotation( DroolsDomainAnnotations.CLASS_REACTIVE_ANNOTATION ); if ( annotation != null ) { view.setClassReactive( Boolean.TRUE ); } annotation = dataObject.getAnnotation( DroolsDomainAnnotations.TYPE_SAFE_ANNOTATION ); if ( annotation != null ) { String value = annotation.getValue( DroolsDomainAnnotations.VALUE_PARAM ) != null ? annotation.getValue( DroolsDomainAnnotations.VALUE_PARAM ).toString() : UIUtil.NOT_SELECTED; view.setTypeSafe( value ); } annotation = dataObject.getAnnotation( DroolsDomainAnnotations.EXPIRES_ANNOTATION ); if ( annotation != null ) { view.setExpires( annotation.getValue( DroolsDomainAnnotations.VALUE_PARAM ).toString() ); } annotation = dataObject.getAnnotation( DroolsDomainAnnotations.JAXB_XML_ROOT_ELEMENT_ANNOTATION ); if ( annotation == null ) { annotation = dataObject.getAnnotation( DroolsDomainAnnotations.REMOTABLE_ANNOTATION ); } if ( annotation != null ) { view.setRemotable( Boolean.TRUE ); } loadDuration( dataObject ); loadTimestamp( dataObject ); setReadonly( getContext() == null || getContext().isReadonly() ); } } @Inject DroolsDataObjectEditor( DroolsDataObjectEditorView view,
DomainHandlerRegistry handlerRegistry,
Event<DataModelerEvent> dataModelerEvent,
DataModelCommandBuilder commandBuilder,
ValidatorService validatorService ); @Override Widget asWidget(); @Override String getName(); @Override String getDomainName(); void setReadonly( boolean readonly ); @Override void onRoleChange(); @Override void onTypeSafeChange(); @Override void onTimeStampFieldChange(); @Override void onDurationFieldChange(); @Override void onPropertyReactiveChange(); @Override void onClassReactiveChange(); @Override void onExpiresChange(); @Override void onRemotableChange(); void clear(); }
|
@Test public void loadDataObjectTest( ) { objectEditor.onContextChange( context ); DataObject dataObject = context.getDataObject( ); verify( view, times( 1 ) ).setTypeSafe( "true" ); verify( view, times( 1 ) ).setPropertyReactive( true ); verify( view, times( 1 ) ).setRole( "EVENT" ); verify( view, times( 1 ) ).setTimeStampField( "field2" ); verify( view, times( 1 ) ).setDurationField( "field3" ); verify( view, times( 1 ) ).setExpires( "1h" ); verify( view, times( 1 ) ).setRemotable( true ); assertFalse( objectEditor.isReadonly( ) ); }
|
SequenceGeneratorEditionDialog implements PropertyEditionPopup { @Override public Widget asWidget() { return view.asWidget(); } @Inject SequenceGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testAsWidget() { Widget widget = mock(Widget.class); when(view.asWidget()).thenReturn(widget); assertEquals(widget, dialog.asWidget()); }
|
SequenceGeneratorEditionDialog implements PropertyEditionPopup { @Override public void show() { DataModelerPropertyEditorFieldInfo fieldInfo = (DataModelerPropertyEditorFieldInfo) property; String sequenceName = (String) fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.SEQUENCE_NAME); String generatorName = (String) fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.NAME); Object initialValue = fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.INITIAL_VALUE); Object allocationSize = fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.ALLOCATION_SIZE); view.setSequenceName(sequenceName); view.setGeneratorName(generatorName); view.setInitialValue(initialValue != null ? initialValue.toString() : null); view.clearInitialValueError(); view.setAllocationSize(allocationSize != null ? allocationSize.toString() : null); view.clearAllocationSizeError(); view.setEnabled(!fieldInfo.isDisabled()); view.show(); } @Inject SequenceGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testShow() { when(fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.SEQUENCE_NAME)).thenReturn(SEQUENCE_NAME_VALUE); when(fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.NAME)).thenReturn(NAME_VALUE); when(fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.INITIAL_VALUE)).thenReturn(INITIAL_VALUE); when(fieldInfo.getCurrentValue(SequenceGeneratorValueHandler.ALLOCATION_SIZE)).thenReturn(ALLOCATION_SIZE_VALUE); when(fieldInfo.isDisabled()).thenReturn(false); dialog.setProperty(fieldInfo); dialog.show(); verify(view).setSequenceName(SEQUENCE_NAME_VALUE); verify(view).setGeneratorName(NAME_VALUE); verify(view).setInitialValue(INITIAL_VALUE.toString()); verify(view).clearInitialValueError(); verify(view).setAllocationSize(ALLOCATION_SIZE_VALUE.toString()); verify(view).clearAllocationSizeError(); verify(view).setEnabled(!fieldInfo.isDisabled()); verify(view).show(); }
|
MoveColumnsCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return new AbstractCanvasCommand() { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { uiModel.moveColumnsTo(index, columns); updateParentInformation(); canvasOperation.execute(); return CanvasCommandResultBuilder.SUCCESS; } @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { uiModel.moveColumnsTo(oldIndex, columns); updateParentInformation(); canvasOperation.execute(); return CanvasCommandResultBuilder.SUCCESS; } }; } MoveColumnsCommand(final Relation relation,
final DMNGridData uiModel,
final int index,
final java.util.List<GridColumn<?>> columns,
final org.uberfire.mvp.Command canvasOperation); void updateParentInformation(); }
|
@Test public void testCanvasCommandAllow() { setupCommand(0, uiModel.getColumns().get(0)); final Command<AbstractCanvasHandler, CanvasViolation> c = command.newCanvasCommand(handler); assertEquals(CanvasCommandResultBuilder.SUCCESS, c.allow(handler)); }
|
SequenceGeneratorEditionDialog implements PropertyEditionPopup { @Override public String getStringValue() { String value = view.getGeneratorName(); if (value == null || value.isEmpty()) { value = SequenceGeneratorField.NOT_CONFIGURED_LABEL; } return value; } @Inject SequenceGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testGetStringValue() { testGetStringValue(NAME_VALUE, NAME_VALUE); }
|
SequenceGeneratorEditionDialog implements PropertyEditionPopup { void onOK() { DataModelerPropertyEditorFieldInfo fieldInfo = (DataModelerPropertyEditorFieldInfo) property; fieldInfo.clearCurrentValues(); String generatorName = view.getGeneratorName(); if (generatorName != null && !generatorName.isEmpty()) { fieldInfo.setCurrentValue(SequenceGeneratorValueHandler.NAME, generatorName); fieldInfo.setCurrentValue(SequenceGeneratorValueHandler.SEQUENCE_NAME, view.getSequenceName()); fieldInfo.setCurrentValue(SequenceGeneratorValueHandler.INITIAL_VALUE, getInitialValue()); fieldInfo.setCurrentValue(SequenceGeneratorValueHandler.ALLOCATION_SIZE, getAllocationSize()); } view.hide(); if (okCommand != null) { okCommand.execute(); } } @Inject SequenceGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testOnOK() { Command command = mock(Command.class); when(view.getSequenceName()).thenReturn(SEQUENCE_NAME_VALUE); when(view.getGeneratorName()).thenReturn(NAME_VALUE); when(view.getInitialValue()).thenReturn(INITIAL_VALUE.toString()); when(view.getAllocationSize()).thenReturn(ALLOCATION_SIZE_VALUE.toString()); dialog.setProperty(fieldInfo); dialog.setOkCommand(command); dialog.onOK(); verify(fieldInfo).setCurrentValue(SequenceGeneratorValueHandler.SEQUENCE_NAME, SEQUENCE_NAME_VALUE); verify(fieldInfo).setCurrentValue(SequenceGeneratorValueHandler.NAME, NAME_VALUE); verify(fieldInfo).setCurrentValue(SequenceGeneratorValueHandler.INITIAL_VALUE, INITIAL_VALUE); verify(fieldInfo).setCurrentValue(SequenceGeneratorValueHandler.ALLOCATION_SIZE, ALLOCATION_SIZE_VALUE); verify(view).hide(); verify(command).execute(); }
|
SequenceGeneratorEditionDialog implements PropertyEditionPopup { void onCancel() { view.hide(); } @Inject SequenceGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testOnCancel() { dialog.onCancel(); verify(view).hide(); }
|
IdGeneratorEditionDialog implements PropertyEditionPopup { @Override public Widget asWidget() { return view.asWidget(); } @Inject IdGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testAsWidget() { Widget widget = mock(Widget.class); when(view.asWidget()).thenReturn(widget); assertEquals(widget, dialog.asWidget()); }
|
IdGeneratorEditionDialog implements PropertyEditionPopup { @Override public void show() { DataModelerPropertyEditorFieldInfo fieldInfo = (DataModelerPropertyEditorFieldInfo) property; String strategy = (String) fieldInfo.getCurrentValue(STRATEGY); String generator = (String) fieldInfo.getCurrentValue(GENERATOR); strategy = strategy != null ? strategy : UIUtil.NOT_SELECTED; view.setGeneratorType(strategy); view.setGeneratorName(generator); view.setEnabled(!fieldInfo.isDisabled()); view.show(); } @Inject IdGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testShow() { when(fieldInfo.getCurrentValue(IdGeneratorField.STRATEGY)).thenReturn(STRATEGY_VALUE); when(fieldInfo.getCurrentValue(IdGeneratorField.GENERATOR)).thenReturn(GENERATOR_VALUE); when(fieldInfo.isDisabled()).thenReturn(false); dialog.setProperty(fieldInfo); dialog.show(); verify(view).setGeneratorType(STRATEGY_VALUE); verify(view).setGeneratorName(GENERATOR_VALUE); verify(view).setEnabled(!fieldInfo.isDisabled()); verify(view).show(); }
|
IdGeneratorEditionDialog implements PropertyEditionPopup { @Override public String getStringValue() { return UIUtil.NOT_SELECTED.equals(view.getGeneratorType()) ? IdGeneratorField.NOT_CONFIGURED_LABEL : view.getGeneratorType(); } @Inject IdGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testGetStringValue() { testGetStringValue("someValue", "someValue"); }
|
IdGeneratorEditionDialog implements PropertyEditionPopup { void onOK() { DataModelerPropertyEditorFieldInfo fieldInfo = (DataModelerPropertyEditorFieldInfo) property; fieldInfo.clearCurrentValues(); String strategy = view.getGeneratorType(); if (!UIUtil.NOT_SELECTED.equals(strategy)) { fieldInfo.setCurrentValue(STRATEGY, strategy); fieldInfo.setCurrentValue(GENERATOR, view.getGeneratorName()); } view.hide(); if (okCommand != null) { okCommand.execute(); } } @Inject IdGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testOnOK() { Command command = mock(Command.class); when(view.getGeneratorType()).thenReturn(STRATEGY_VALUE); when(view.getGeneratorName()).thenReturn(GENERATOR_VALUE); dialog.setProperty(fieldInfo); dialog.setOkCommand(command); dialog.onOK(); verify(fieldInfo).setCurrentValue(STRATEGY, STRATEGY_VALUE); verify(fieldInfo).setCurrentValue(GENERATOR, GENERATOR_VALUE); verify(view).hide(); verify(command).execute(); }
|
IdGeneratorEditionDialog implements PropertyEditionPopup { void onCancel() { view.hide(); } @Inject IdGeneratorEditionDialog(View view); @Override Widget asWidget(); @Override void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testOnCancel() { dialog.onCancel(); verify(view).hide(); }
|
RelationshipEditionDialog implements PropertyEditionPopup { @Override public Widget asWidget() { return view.asWidget(); } @Inject RelationshipEditionDialog(View view); @Override Widget asWidget(); @Override @SuppressWarnings("unchecked") void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testAsWidget() { Widget widget = mock(Widget.class); when(view.asWidget()).thenReturn(widget); assertEquals(widget, dialog.asWidget()); }
|
RelationshipEditionDialog implements PropertyEditionPopup { @Override @SuppressWarnings("unchecked") public void show() { DataModelerPropertyEditorFieldInfo fieldInfo = (DataModelerPropertyEditorFieldInfo) property; RelationType relationTypeValue = (RelationType) fieldInfo.getCurrentValue(RELATION_TYPE); if (relationTypeValue != null) { view.setRelationType(relationTypeValue.name()); } else { view.setRelationType(UIUtil.NOT_SELECTED); } enableRelationDependentFields(relationTypeValue); cascadeAllWasClicked = false; setCascadeTypes((List<CascadeType>) fieldInfo.getCurrentValue(CASCADE)); enableCascadeTypes(true, true); FetchMode fetchModeValue = (FetchMode) fieldInfo.getCurrentValue(FETCH); if (fetchModeValue != null) { view.setFetchMode(fetchModeValue.name()); } else { view.setFetchMode(UIUtil.NOT_SELECTED); } Boolean optionalValue = (Boolean) fieldInfo.getCurrentValue(OPTIONAL); if (optionalValue != null) { view.setOptional(optionalValue); } String mappedBy = (String) fieldInfo.getCurrentValue(MAPPED_BY); view.setMappedBy(mappedBy); Boolean orphanRemovalValue = (Boolean) fieldInfo.getCurrentValue(ORPHAN_REMOVAL); if (orphanRemovalValue != null) { view.setOrphanRemoval(orphanRemovalValue); } view.setEnabled(!fieldInfo.isDisabled()); view.show(); } @Inject RelationshipEditionDialog(View view); @Override Widget asWidget(); @Override @SuppressWarnings("unchecked") void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testShow() { RelationType relationTypeValue = RelationType.ONE_TO_MANY; List<CascadeType> cascadeTypeValue = Arrays.asList(CascadeType.DETACH, CascadeType.MERGE); FetchMode fetchModeValue = FetchMode.EAGER; Boolean optionalValue = Boolean.TRUE; String mappedByValue = "mappedByValue"; Boolean orphanRemovalValue = Boolean.FALSE; when(fieldInfo.getCurrentValue(RelationshipAnnotationValueHandler.RELATION_TYPE)).thenReturn(relationTypeValue); when(fieldInfo.getCurrentValue(RelationshipAnnotationValueHandler.CASCADE)).thenReturn(cascadeTypeValue); when(fieldInfo.getCurrentValue(RelationshipAnnotationValueHandler.FETCH)).thenReturn(fetchModeValue); when(fieldInfo.getCurrentValue(RelationshipAnnotationValueHandler.OPTIONAL)).thenReturn(optionalValue); when(fieldInfo.getCurrentValue(RelationshipAnnotationValueHandler.MAPPED_BY)).thenReturn(mappedByValue); when(fieldInfo.getCurrentValue(RelationshipAnnotationValueHandler.ORPHAN_REMOVAL)).thenReturn(orphanRemovalValue); when(fieldInfo.isDisabled()).thenReturn(false); dialog.setProperty(fieldInfo); dialog.show(); verify(view).setRelationType(relationTypeValue.name()); verifyRelationDependentFields(relationTypeValue); verifyCascadeTypesWhereSet(cascadeTypeValue); verify(view).setFetchMode(fetchModeValue.name()); verify(view).setOptional(optionalValue); verify(view).setMappedBy(mappedByValue); verify(view).setOrphanRemoval(orphanRemovalValue); verify(view).setEnabled(!fieldInfo.isDisabled()); verify(view).show(); }
|
AddRelationRowCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler handler) { return new AbstractGraphCommand() { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext gce) { return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext gce) { relation.getRow().add(uiRowIndex, row); relation.getColumn().forEach(ii -> { final LiteralExpression le = new LiteralExpression(); final HasExpression hasExpression = HasExpression.wrap(ii, le); row.getExpression().add(hasExpression); le.setParent(row); }); row.setParent(relation); return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext gce) { relation.getRow().remove(row); return GraphCommandResultBuilder.SUCCESS; } }; } AddRelationRowCommand(final Relation relation,
final List row,
final GridData uiModel,
final GridRow uiModelRow,
final int uiRowIndex,
final RelationUIModelMapper uiModelMapper,
final org.uberfire.mvp.Command canvasOperation); void updateRowNumbers(); void updateParentInformation(); }
|
@Test public void testGraphCommandAllow() { final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.allow(gce)); }
@Test public void testGraphCommandExecuteWithColumns() { relation.getColumn().add(new InformationItem()); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(1, relation.getRow().size()); assertEquals(row, relation.getRow().get(0)); assertEquals(1, relation.getColumn().size()); assertEquals(1, relation.getRow().get(0).getExpression().size()); assertTrue(relation.getRow().get(0).getExpression().get(0).getExpression() instanceof LiteralExpression); assertEquals(relation, row.getParent()); assertEquals(relation.getRow().get(0), relation.getRow().get(0).getExpression().get(0).getExpression().getParent()); }
@Test public void testGraphCommandExecuteInsertMiddleWithColumns() { relation.getRow().add(new List()); relation.getRow().add(new List()); relation.getColumn().add(new InformationItem()); makeCommand(1); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(3, relation.getRow().size()); assertEquals(row, relation.getRow().get(1)); assertEquals(1, relation.getColumn().size()); assertEquals(1, relation.getRow().get(1).getExpression().size()); assertTrue(relation.getRow().get(1).getExpression().get(0).getExpression() instanceof LiteralExpression); assertEquals(relation, row.getParent()); assertEquals(relation.getRow().get(1), relation.getRow().get(1).getExpression().get(0).getExpression().getParent()); }
@Test public void testGraphCommandExecuteWithNoColumns() { final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(1, relation.getRow().size()); assertEquals(row, relation.getRow().get(0)); assertEquals(relation, row.getParent()); }
@Test public void testGraphCommandUndoWithColumns() { relation.getColumn().add(new InformationItem()); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(GraphCommandResultBuilder.SUCCESS, c.undo(gce)); assertEquals(1, relation.getColumn().size()); assertEquals(0, relation.getRow().size()); }
@Test public void testGraphCommandUndoWithNoColumns() { final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(GraphCommandResultBuilder.SUCCESS, c.undo(gce)); assertEquals(0, relation.getColumn().size()); assertEquals(0, relation.getRow().size()); }
|
RelationshipEditionDialog implements PropertyEditionPopup { void enableRelationDependentFields(RelationType relationType) { if (relationType != null) { switch (relationType) { case ONE_TO_ONE: view.setOptionalVisible(true); view.setMappedByVisible(true); view.setOrphanRemovalVisible(true); break; case ONE_TO_MANY: view.setOptionalVisible(false); view.setMappedByVisible(true); view.setOrphanRemovalVisible(true); break; case MANY_TO_ONE: view.setOptionalVisible(true); view.setMappedByVisible(false); view.setOrphanRemovalVisible(false); break; case MANY_TO_MANY: view.setOptionalVisible(false); view.setMappedByVisible(true); view.setOrphanRemovalVisible(false); } } } @Inject RelationshipEditionDialog(View view); @Override Widget asWidget(); @Override @SuppressWarnings("unchecked") void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testRelationDependentFieldsOneToOne() { dialog.enableRelationDependentFields(RelationType.ONE_TO_ONE); verifyRelationDependentFields(RelationType.ONE_TO_ONE); }
@Test public void testRelationDependentFieldsOneToMany() { dialog.enableRelationDependentFields(RelationType.ONE_TO_MANY); verifyRelationDependentFields(RelationType.ONE_TO_MANY); }
@Test public void testRelationDependentFieldsManyToOne() { dialog.enableRelationDependentFields(RelationType.MANY_TO_ONE); verifyRelationDependentFields(RelationType.MANY_TO_ONE); }
@Test public void testRelationDependentFieldsManyToMany() { dialog.enableRelationDependentFields(RelationType.MANY_TO_MANY); verifyRelationDependentFields(RelationType.MANY_TO_MANY); }
|
RelationshipEditionDialog implements PropertyEditionPopup { @Override public String getStringValue() { return UIUtil.NOT_SELECTED.equals(view.getRelationType()) ? RelationshipField.NOT_CONFIGURED_LABEL : view.getRelationType(); } @Inject RelationshipEditionDialog(View view); @Override Widget asWidget(); @Override @SuppressWarnings("unchecked") void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testGetStringValue() { testGetStringValue("someValue", "someValue"); }
|
RelationshipEditionDialog implements PropertyEditionPopup { void onCancel() { view.hide(); } @Inject RelationshipEditionDialog(View view); @Override Widget asWidget(); @Override @SuppressWarnings("unchecked") void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testOnCancel() { dialog.onCancel(); verify(view).hide(); }
|
RelationshipEditionDialog implements PropertyEditionPopup { void onCascadeAllChanged() { if (view.getCascadeAll()) { enableCascadeTypes(true, false); view.setCascadePersist(true); view.setCascadeMerge(true); view.setCascadeRemove(true); view.setCascadeRefresh(true); view.setCascadeDetach(true); } else { enableCascadeTypes(true, true); if (cascadeAllWasClicked) { view.setCascadePersist(false); view.setCascadeMerge(false); view.setCascadeRemove(false); view.setCascadeRefresh(false); view.setCascadeDetach(false); } } cascadeAllWasClicked = true; } @Inject RelationshipEditionDialog(View view); @Override Widget asWidget(); @Override @SuppressWarnings("unchecked") void show(); @Override void setOkCommand(Command okCommand); @Override void setProperty(PropertyEditorFieldInfo property); @Override String getStringValue(); @Override void setStringValue(String value); }
|
@Test public void testOnCascadeAllChangedTrue() { when(view.getCascadeAll()).thenReturn(true); dialog.onCascadeAllChanged(); verifyCascadeTypesEnabled(1, true, false, false, false, false, false); verifyCascadeTypesValues(true, true, true, true, true); }
@Test public void testOnCascadeAllChangedFalse() { when(view.getCascadeAll()).thenReturn(false); dialog.onCascadeAllChanged(); verifyCascadeTypesEnabled(1, true, true, true, true, true, true); verify(view, never()).setCascadePersist(anyBoolean()); verify(view, never()).setCascadeMerge(anyBoolean()); verify(view, never()).setCascadeRemove(anyBoolean()); verify(view, never()).setCascadeRefresh(anyBoolean()); verify(view, never()).setCascadeDetach(anyBoolean()); }
@Test public void testOnCascadeAllChangedFalse2() { when(view.getCascadeAll()).thenReturn(false); dialog.onCascadeAllChanged(); dialog.onCascadeAllChanged(); verifyCascadeTypesEnabled(2, true, true, true, true, true, true); verifyCascadeTypesValues(false, false, false, false, false); }
|
JPADataObjectFieldEditor extends FieldEditor implements JPADataObjectFieldEditorView.Presenter { @Override protected void loadDataObjectField(DataObject dataObject, ObjectProperty objectField) { clear(); setReadonly(true); if (dataObject != null && objectField != null) { this.dataObject = dataObject; this.objectField = objectField; updateIdentifierField(objectField.getAnnotation(JPADomainAnnotations.JAVAX_PERSISTENCE_ID_ANNOTATION)); updateColumnFields(objectField.getAnnotation(JPADomainAnnotations.JAVAX_PERSISTENCE_COLUMN_ANNOTATION)); updateGeneratedValueField(objectField.getAnnotation(JPADomainAnnotations.JAVAX_PERSISTENCE_GENERATED_VALUE_ANNOTATION)); updateSequenceGeneratorField(objectField.getAnnotation(JPADomainAnnotations.JAVAX_PERSISTENCE_SEQUENCE_GENERATOR_ANNOTATION)); updateRelationshipField(getCurrentRelationshipAnnotation(objectField)); setReadonly(getContext() == null || getContext().isReadonly()); } loadPropertyEditor(); } @Inject JPADataObjectFieldEditor(JPADataObjectFieldEditorView view,
DomainHandlerRegistry handlerRegistry,
Event<DataModelerEvent> dataModelerEvent,
DataModelCommandBuilder commandBuilder); @Override Widget asWidget(); @Override String getName(); @Override String getDomainName(); @Override void onIdentifierFieldChange(DataModelerPropertyEditorFieldInfo fieldInfo, String newValue); @Override void onColumnFieldChange(DataModelerPropertyEditorFieldInfo fieldInfo, String newValue); @Override void onGeneratedValueFieldChange(DataModelerPropertyEditorFieldInfo fieldInfo, String newValue); @Override void onSequenceGeneratorFieldChange(DataModelerPropertyEditorFieldInfo fieldInfo, String newValue); @Override void onRelationTypeFieldChange(DataModelerPropertyEditorFieldInfo fieldInfo, String newValue); void clear(); }
|
@Test public void loadDataObjectFieldTest() { JPADataObjectFieldEditor fieldEditor = createFieldEditor(); DataObject dataObject = context.getDataObject(); ObjectProperty field = dataObject.getProperty( "field1" ); context.setObjectProperty( field ); fieldEditor.onContextChange( context ); verify( view, times( 2 ) ).loadPropertyEditorCategories( anyListOf( PropertyEditorCategory.class ) ); assertFalse( fieldEditor.isReadonly() ); }
|
JPADataObjectEditor extends ObjectEditor implements JPADataObjectEditorView.Presenter { @Override protected void loadDataObject(DataObject dataObject) { clear(); setReadonly(true); this.dataObject = dataObject; if (dataObject != null) { updateEntityField(dataObject.getAnnotation(JPADomainAnnotations.JAVAX_PERSISTENCE_ENTITY_ANNOTATION)); updateTableNameField(dataObject.getAnnotation(JPADomainAnnotations.JAVAX_PERSISTENCE_TABLE_ANNOTATION)); updateAuditedField(dataObject.getAnnotation(JPADomainAnnotations.HIBERNATE_ENVERS_AUDITED)); setReadonly(getContext() == null || getContext().isReadonly()); } loadPropertyEditor(); } @Inject JPADataObjectEditor(JPADataObjectEditorView view,
DomainHandlerRegistry handlerRegistry,
Event<DataModelerEvent> dataModelerEvent,
DataModelCommandBuilder commandBuilder); @Override Widget asWidget(); @Override String getName(); @Override String getDomainName(); @Override void onEntityFieldChange(String newValue); @Override void onTableNameChange(String newValue); @Override void onAuditedFieldChange(String newValue); @Override void clear(); }
|
@Test public void loadDataObjectTest() { JPADataObjectEditor objectEditor = createObjectEditor(); objectEditor.onContextChange( context ); verify( view, times( 2 ) ).loadPropertyEditorCategories( anyListOf( PropertyEditorCategory.class ) ); assertFalse( objectEditor.isReadonly() ); }
|
DataObjectBrowser implements IsWidget,
DataObjectBrowserView.Presenter { void onDataObjectFieldDeleted(@Observes DataObjectFieldDeletedEvent event) { if (event.isFromContext(context != null ? context.getContextId() : null) && !DataModelerEvent.DATA_OBJECT_BROWSER.equals(event.getSource())) { setDataObject(dataObject); } } @Inject DataObjectBrowser(DomainHandlerRegistry handlerRegistry,
DataModelCommandBuilder commandBuilder,
Caller<DataModelerService> modelerService,
Caller<DataObjectValidationService> dataObjectValidationService,
ValidatorService validatorService,
Event<DataModelerEvent> dataModelerEvent,
Event<DataModelerWorkbenchContextChangeEvent> dataModelerWBContextEvent,
Event<LockRequiredEvent> lockRequiredEvent,
PlaceManager placeManager,
NewFieldPopup newFieldPopup,
DataObjectBrowserView view,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer); @Override Widget asWidget(); DataModelerContext getContext(); void setContext(DataModelerContext context); @Override void onDeleteProperty(final ObjectProperty objectProperty,
final int index); DataModel getDataModel(); DataObject getDataObject(); void onSelectPropertyType(ObjectProperty property); boolean isReadonly(); void redrawFields(); @Override void onSelectCurrentDataObject(); @Override void onNewProperty(); @Override void onSelectProperty(ObjectProperty selectedProperty); @Override void onSortByName(boolean ascending); @Override void onSortByLabel(boolean ascending); @Override void onSortByType(boolean ascending); @Override String getPropertyTypeDisplayValue(ObjectProperty property); @Override boolean isSelectablePropertyType(ObjectProperty property); }
|
@Test public void onDataObjectFieldDeleted() { DataObjectBrowser dataObjectBrowser = spy(createBrowser()); DataModelerContext context = createContext(); context.setContextId("contextId"); dataObjectBrowser.setContext(context); DataObject dataObject = mock(DataObject.class); dataObjectBrowser.setDataObject(dataObject); DataObjectFieldDeletedEvent event = new DataObjectFieldDeletedEvent(); event.setContextId("contextId"); Mockito.reset(dataObjectBrowser); dataObjectBrowser.onDataObjectFieldDeleted(event); verify(dataObjectBrowser, times(1)).setDataObject(dataObject); }
|
DataObjectBrowserViewImpl extends Composite implements DataObjectBrowserView { @Override public void showValidationPopupForDeletion(List<ValidationMessage> validationMessages, Command yesCommand, Command cancelCommand) { validationPopup.showDeleteValidationMessages(yesCommand, cancelCommand, validationMessages); } @Inject DataObjectBrowserViewImpl(final ValidationPopup validationPopup,
final Instance<FieldMetadataProvider> fieldMetadataProviderInstance); @Override void init(Presenter presenter); @Override void setDataProvider(ListDataProvider<ObjectProperty> dataProvider); void setObjectSelectorLabel(String label,
String title); void setReadonly(boolean readonly); void enableNewPropertyAction(boolean enable); @Override void enableDeleteRowAction(boolean enable); @Override void redrawRow(int row); @Override void redrawTable(); @Override ObjectProperty getSelectedRow(); @Override void setSelectedRow(ObjectProperty objectProperty,
boolean select); @Override void setTableHeight(int height); @Override int getTableHeight(); @Override void showBusyIndicator(String message); @Override void hideBusyIndicator(); @Override void showYesNoCancelPopup(final String title,
final String content,
final Command yesCommand,
final String yesButtonText,
final ButtonType yesButtonType,
final Command noCommand,
final String noButtonText,
final ButtonType noButtonType,
final Command cancelCommand,
final String cancelButtonText,
final ButtonType cancelButtonType); @Override void showValidationPopupForDeletion(List<ValidationMessage> validationMessages,
Command yesCommand,
Command cancelCommand); }
|
@Test public void showValidationPopupForDeletion() { List<ValidationMessage> validationMessages = Collections.EMPTY_LIST; Command yesCommand = () -> { }; Command noCommand = () -> { }; view.showValidationPopupForDeletion(validationMessages, yesCommand, noCommand); verify(validationPopup, Mockito.times(1)).showDeleteValidationMessages( yesCommand, noCommand, validationMessages); }
|
DataObjectBrowserViewImpl extends Composite implements DataObjectBrowserView { private void addPropertyTypeBrowseColumn() { propertiesTable.addColumn(createPropertyTypeBrowseColumn(), " "); } @Inject DataObjectBrowserViewImpl(final ValidationPopup validationPopup,
final Instance<FieldMetadataProvider> fieldMetadataProviderInstance); @Override void init(Presenter presenter); @Override void setDataProvider(ListDataProvider<ObjectProperty> dataProvider); void setObjectSelectorLabel(String label,
String title); void setReadonly(boolean readonly); void enableNewPropertyAction(boolean enable); @Override void enableDeleteRowAction(boolean enable); @Override void redrawRow(int row); @Override void redrawTable(); @Override ObjectProperty getSelectedRow(); @Override void setSelectedRow(ObjectProperty objectProperty,
boolean select); @Override void setTableHeight(int height); @Override int getTableHeight(); @Override void showBusyIndicator(String message); @Override void hideBusyIndicator(); @Override void showYesNoCancelPopup(final String title,
final String content,
final Command yesCommand,
final String yesButtonText,
final ButtonType yesButtonType,
final Command noCommand,
final String noButtonText,
final ButtonType noButtonType,
final Command cancelCommand,
final String cancelButtonText,
final ButtonType cancelButtonType); @Override void showValidationPopupForDeletion(List<ValidationMessage> validationMessages,
Command yesCommand,
Command cancelCommand); }
|
@Test public void addPropertyTypeBrowseColumn() { FieldMetadataProvider fieldMetadataProvider = objectProperty -> { if ("testField".equals(objectProperty.getName())) { ImageWrapper imageWrapper = new ImageWrapper("testUri", "testDescription"); FieldMetadata fieldMetadata = new FieldMetadata(imageWrapper); return Optional.of(fieldMetadata); } return Optional.empty(); }; Instance<FieldMetadataProvider> fieldMetadataProviderInstance = new MockInstanceImpl<>(fieldMetadataProvider); view = new DataObjectBrowserViewImpl(validationPopup, fieldMetadataProviderInstance); Column<ObjectProperty, List<ImageWrapper>> column = view.createPropertyTypeBrowseColumn(); ObjectProperty matchingObjectProperty = new ObjectPropertyImpl("testField", "className", false); List<ImageWrapper> imageWrapperList = column.getValue(matchingObjectProperty); assertEquals(1, imageWrapperList.size()); ObjectProperty nonMatchingObjectProperty = new ObjectPropertyImpl("nonMatchingTestField", "className", false); imageWrapperList = column.getValue(nonMatchingObjectProperty); assertEquals(0, imageWrapperList.size()); }
|
CreateAnnotationWizard extends AbstractWizard { @Override public void complete() { doComplete(); super.complete(); } @Inject CreateAnnotationWizard(SearchAnnotationPage searchAnnotationPage,
SyncBeanManager iocManager); void init(KieModule module, ElementType target); @Override List<WizardPage> getPages(); @Override Widget getPageWidget(int pageNumber); @Override String getTitle(); @Override int getPreferredHeight(); @Override int getPreferredWidth(); @Override void isComplete(final Callback<Boolean> callback); void onCloseCallback(final Callback<Annotation> callback); @Override void complete(); @Override void close(); }
|
@Test public void testAnnotationCreated() { AnnotationDefinitionRequest request = new AnnotationDefinitionRequest(Entity.class.getName()); AnnotationDefinitionResponse response = new AnnotationDefinitionResponse( DriverUtils.buildAnnotationDefinition(Entity.class)); when(searchView.getClassName()).thenReturn(Entity.class.getName()); when(modelerService.resolveDefinitionRequest(request, kieModule)).thenReturn(response); AnnotationValuePairDefinition valuePairDefinition = response.getAnnotationDefinition().getValuePair("name"); when(valuePairEditorProvider.getValuePairEditor(valuePairDefinition)).thenReturn(valuePairEditor); when(iocManager.lookupBean(ValuePairEditorPage.class)).thenReturn(beanDef); when(beanDef.getInstance()).thenReturn(editorPage); searchPage.onSearchClass(); WizardTestUtil.assertPageComplete(true, searchPage); when(editorView.getValuePairEditor()).thenReturn(valuePairEditor); when(valuePairEditor.getValue()).thenReturn("TheEntityName"); when(valuePairEditor.isValid()).thenReturn(true); editorPage.onValueChange(); WizardTestUtil.assertPageComplete(true, searchPage); createAnnotationWizard.complete(); Annotation expectedAnnotation = new AnnotationImpl(DriverUtils.buildAnnotationDefinition(Entity.class)); expectedAnnotation.setValue("name", "TheEntityName"); assertEquals(expectedAnnotation, createdAnnotation); }
|
ValuePairEditorPage extends CreateAnnotationWizardPage implements ValuePairEditorPageView.Presenter { public void init(AnnotationDefinition annotationDefinition, AnnotationValuePairDefinition valuePairDefinition, ElementType target, KieModule project) { this.annotationDefinition = annotationDefinition; setValuePairDefinition(valuePairDefinition); this.target = target; this.project = project; setStatus(isRequired() ? PageStatus.NOT_VALIDATED : PageStatus.VALIDATED); } @Inject ValuePairEditorPage(ValuePairEditorPageView view,
ValuePairEditorProvider valuePairEditorProvider,
Caller<DataModelerService> modelerService,
Event<WizardPageStatusChangeEvent> wizardPageStatusChangeEvent); @Override Widget asWidget(); void init(AnnotationDefinition annotationDefinition,
AnnotationValuePairDefinition valuePairDefinition, ElementType target, KieModule project); String getStringValue(); AnnotationValuePairDefinition getValuePairDefinition(); Object getCurrentValue(); @Override void onValidate(); @Override void onValueChange(); }
|
@Test public void testPageInitialization() { modelerServiceCaller = new CallerMock<DataModelerService>(modelerService); ValuePairEditorPage editorPage = new ValuePairEditorPage(view, valuePairEditorProvider, modelerServiceCaller, wizardPageStatusChangeEvent); editorPage.prepareView(); AnnotationDefinition annotationDefinition = DriverUtils.buildAnnotationDefinition(Entity.class); AnnotationValuePairDefinition valuePairDefinition = annotationDefinition.getValuePair("name"); when(valuePairEditorProvider.getValuePairEditor(valuePairDefinition)).thenReturn(valuePairEditor); editorPage.init(annotationDefinition, valuePairDefinition, ElementType.FIELD, kieModule); verify(view, times(1)).setValuePairEditor(valuePairEditor); WizardTestUtil.assertPageComplete(true, editorPage); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { public void loadAnnotations(List<Annotation> annotations) { this.annotations = annotations; if (annotations != null && annotations.size() > 0) { AnnotationSourceRequest sourceRequest = new AnnotationSourceRequest(); sourceRequest.withAnnotations(annotations); modelerService.call(getLoadAnnotationSourcesSuccessCallback()) .resolveSourceRequest(sourceRequest); } } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testLoadAnnotationsWithoutSources() { when(dataModelerService.resolveSourceRequest(any(AnnotationSourceRequest.class))).thenReturn(sourceResponse); when(sourceResponse.getAnnotationSources()).thenReturn(annotationSourcesMap); annotationListEditor.loadAnnotations(annotations); verifyAnnotationsLoaded(); }
@Test public void testLoadAnnotationsWithSources() { annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); verifyAnnotationsLoaded(); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { @Override public void onAddAnnotation() { view.invokeCreateAnnotationWizard(getAddAnnotationCallback(), module, elementType); } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testOnAddAnnotation() { annotationListEditor.init(kieModule, elementType); annotationListEditor.onAddAnnotation(); verify(view, times(1)).invokeCreateAnnotationWizard(annotationCallbackCaptor.capture(), eq(kieModule), eq(elementType)); annotationCallbackCaptor.getValue().callback(annotation); verify(addAnnotationHandler, times(1)).onAddAnnotation(annotation); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { protected void onDeleteAnnotation(final Annotation annotation) { String message = Constants.INSTANCE.advanced_domain_annotation_list_editor_message_confirm_annotation_deletion( annotation.getClassName(), (elementType != null ? elementType.name() : " object/field")); view.showYesNoDialog(message, getDeleteAnnotationCommand(annotation), getNoActionCommand(), getNoActionCommand()); } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testOnDeleteAnnotation() { annotationListEditor.init(kieModule, elementType); annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); Annotation selectedAnnotation = annotations.get(2); annotationListEditor.onDeleteAnnotation(selectedAnnotation); String expectedMessage = Constants.INSTANCE.advanced_domain_annotation_list_editor_message_confirm_annotation_deletion( selectedAnnotation.getClassName(), elementType.name()); verify(view, times(1)).showYesNoDialog(eq(expectedMessage), yesCommandCaptor.capture(), noCommandCaptor.capture(), cancelCommandCaptor.capture()); yesCommandCaptor.getValue().execute(); verify(deleteAnnotationHandler, times(1)).onDeleteAnnotation(selectedAnnotation); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { protected void onClearValuePair(Annotation annotation, String valuePair) { AnnotationDefinition annotationDefinition = annotation.getAnnotationDefinition(); AnnotationValuePairDefinition valuePairDefinition = annotationDefinition.getValuePair(valuePair); if (valuePairDefinition.getDefaultValue() == null) { String message = Constants.INSTANCE.advanced_domain_annotation_list_editor_message_value_pair_has_no_default_value(valuePair, annotation.getClassName()); view.showYesNoDialog(message, getNoActionCommand()); } else if (clearValuePairHandler != null) { clearValuePairHandler.onClearValuePair(annotation, valuePair); } } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testOnClearValuePairWithoutDefaultValue() { prepareValuePairClear(); when(valuePairDefinition.getDefaultValue()).thenReturn(null); annotationListEditor.onClearValuePair(annotation, "valuePairName"); String expectedMessage = Constants.INSTANCE.advanced_domain_annotation_list_editor_message_value_pair_has_no_default_value("valuePairName", "AnnotationClassName"); verify(view, times(1)).showYesNoDialog(eq(expectedMessage), yesCommandCaptor.capture()); yesCommandCaptor.getValue().execute(); verify(clearValuePairHandler, times(0)).onClearValuePair(eq(annotation), anyString()); }
@Test public void testOnClearValuePairWithDefaultValue() { prepareValuePairClear(); Object someValue = mock(Object.class); when(valuePairDefinition.getDefaultValue()).thenReturn(someValue); annotationListEditor.onClearValuePair(annotation, "valuePairName"); verify(clearValuePairHandler, times(1)).onClearValuePair(annotation, "valuePairName"); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { public void clear() { view.clear(); clearListItems(); } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testClear() { annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); annotationListEditor.clear(); verify(view, times(2)).clear(); verifyItemsCleared(); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { @PreDestroy protected void destroy() { clearListItems(); } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testDestroy() { annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); annotationListEditor.destroy(); verifyItemsCleared(); }
|
AdvancedAnnotationListEditor implements IsWidget,
AdvancedAnnotationListEditorView.Presenter { public void removeAnnotation(Annotation annotation) { AnnotationListItem listItem = annotationItems.get(annotation); if (listItem != null) { view.removeItem(listItem); annotationItems.remove(annotation); dispose(listItem); } } @Inject AdvancedAnnotationListEditor(AdvancedAnnotationListEditorView view,
Caller<DataModelerService> modelerService,
Instance<ValuePairEditorPopup> valuePairEditorInstance,
Instance<AnnotationListItem> itemInstance); @Override Widget asWidget(); void init(final KieModule module,
final ElementType elementType); void loadAnnotations(List<Annotation> annotations); void loadAnnotations(List<Annotation> annotations,
Map<String, AnnotationSource> annotationSources); boolean isReadonly(); void setReadonly(boolean readonly); @Override void onAddAnnotation(); void addDeleteAnnotationHandler(AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler); void addClearValuePairHandler(AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler); void addValuePairChangeHandler(AdvancedAnnotationListEditorView.ValuePairChangeHandler valuePairChangeHandler); void addAddAnnotationHandler(AdvancedAnnotationListEditorView.AddAnnotationHandler addAnnotationHandler); void clear(); void removeAnnotation(Annotation annotation); }
|
@Test public void testRemoveAnnotation() { annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); annotationListEditor.removeAnnotation(annotations.get(2)); verify(view, times(1)).removeItem(itemInstances.get(2)); verify(itemInstance, times(1)).destroy(itemInstances.get(2)); }
|
AnnotationListItem implements AnnotationListItemView.Presenter, IsWidget { public void loadAnnotation( Annotation annotation, AnnotationSource annotationSource ) { this.annotation = annotation; view.setHeadingTitle( annotation.getClassName( ) ); if ( annotation.getAnnotationDefinition( ) != null && annotation.getAnnotationDefinition( ).getValuePairs( ) != null ) { for ( AnnotationValuePairDefinition valuePairDefinition : annotation.getAnnotationDefinition( ).getValuePairs( ) ) { AnnotationValuePairListItem valuePairListItem = createListItem(); valuePairListItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); valuePairListItem.setClearValuePairHandler( new AdvancedAnnotationListEditorView.ClearValuePairHandler( ) { @Override public void onClearValuePair( Annotation annotation, String valuePair ) { if ( clearValuePairHandler != null ) { clearValuePairHandler.onClearValuePair( annotation, valuePair ); } } } ); valuePairListItem.setEditValuePairHandler( new AdvancedAnnotationListEditorView.EditValuePairHandler( ) { @Override public void onEditValuePair( Annotation annotation, String valuePair ) { if ( editValuePairHandler != null ) { editValuePairHandler.onEditValuePair( annotation, valuePair ); } } } ); view.addItem( valuePairListItem ); items.add( valuePairListItem ); } } } AnnotationListItem( ); @Inject AnnotationListItem( AnnotationListItemView view, Instance<AnnotationValuePairListItem> itemInstance ); @Override Widget asWidget( ); void loadAnnotation( Annotation annotation, AnnotationSource annotationSource ); void setDeleteAnnotationHandler( AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); void setCollapseChangeHandler( AdvancedAnnotationListEditorView.CollapseChangeHandler collapseChangeHandler ); boolean isCollapsed( ); void setCollapsed( boolean collapsed ); void setReadonly( boolean readonly ); @Override void onDelete( ); @Override void onCollapseChange( ); }
|
@Test public void testLoadAnnotation( ) { listItem.loadAnnotation( annotation, annotationSource ); verify( view, times( 1 ) ).setHeadingTitle( ANNOTATION_CLASS_NAME ); verify( itemInstance, times( valuePairs.size( ) ) ).get( ); for ( int i = 0; i < valuePairItems.size( ); i++ ) { verify( valuePairItems.get( i ), times( 1 ) ).loadValuePair( annotation, valuePairs.get( i ), annotationSource ); verify( valuePairItems.get( i ), times( 1 ) ).setClearValuePairHandler( any( AdvancedAnnotationListEditorView.ClearValuePairHandler.class ) ); verify( valuePairItems.get( i ), times( 1 ) ).setEditValuePairHandler( any( AdvancedAnnotationListEditorView.EditValuePairHandler.class ) ); verify( view, times( 1 ) ).addItem( valuePairItems.get( i ) ); } }
|
AnnotationListItem implements AnnotationListItemView.Presenter, IsWidget { public void setCollapsed( boolean collapsed ) { view.setCollapsed( collapsed ); } AnnotationListItem( ); @Inject AnnotationListItem( AnnotationListItemView view, Instance<AnnotationValuePairListItem> itemInstance ); @Override Widget asWidget( ); void loadAnnotation( Annotation annotation, AnnotationSource annotationSource ); void setDeleteAnnotationHandler( AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); void setCollapseChangeHandler( AdvancedAnnotationListEditorView.CollapseChangeHandler collapseChangeHandler ); boolean isCollapsed( ); void setCollapsed( boolean collapsed ); void setReadonly( boolean readonly ); @Override void onDelete( ); @Override void onCollapseChange( ); }
|
@Test public void testSetCollapsedTrue( ) { listItem.setCollapsed( true ); verify( view, times( 1 ) ).setCollapsed( true ); }
@Test public void testSetCollapsedFalse( ) { listItem.setCollapsed( false ); verify( view, times( 1 ) ).setCollapsed( false ); }
|
AnnotationListItem implements AnnotationListItemView.Presenter, IsWidget { @Override public void onCollapseChange( ) { if ( collapseChangeHandler != null ) { collapseChangeHandler.onCollapseChange( ); } } AnnotationListItem( ); @Inject AnnotationListItem( AnnotationListItemView view, Instance<AnnotationValuePairListItem> itemInstance ); @Override Widget asWidget( ); void loadAnnotation( Annotation annotation, AnnotationSource annotationSource ); void setDeleteAnnotationHandler( AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); void setCollapseChangeHandler( AdvancedAnnotationListEditorView.CollapseChangeHandler collapseChangeHandler ); boolean isCollapsed( ); void setCollapsed( boolean collapsed ); void setReadonly( boolean readonly ); @Override void onDelete( ); @Override void onCollapseChange( ); }
|
@Test public void testOnCollapseChange( ) { listItem.setCollapseChangeHandler( collapseChangeHandler ); listItem.onCollapseChange( ); verify( collapseChangeHandler, times( 1 ) ).onCollapseChange( ); }
|
AnnotationListItem implements AnnotationListItemView.Presenter, IsWidget { @Override public void onDelete( ) { if ( deleteAnnotationHandler != null ) { deleteAnnotationHandler.onDeleteAnnotation( annotation ); } } AnnotationListItem( ); @Inject AnnotationListItem( AnnotationListItemView view, Instance<AnnotationValuePairListItem> itemInstance ); @Override Widget asWidget( ); void loadAnnotation( Annotation annotation, AnnotationSource annotationSource ); void setDeleteAnnotationHandler( AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); void setCollapseChangeHandler( AdvancedAnnotationListEditorView.CollapseChangeHandler collapseChangeHandler ); boolean isCollapsed( ); void setCollapsed( boolean collapsed ); void setReadonly( boolean readonly ); @Override void onDelete( ); @Override void onCollapseChange( ); }
|
@Test public void testOnDelete( ) { listItem.loadAnnotation( annotation, annotationSource ); listItem.setDeleteAnnotationHandler( deleteAnnotationHandler ); listItem.onDelete( ); verify( deleteAnnotationHandler, times( 1 ) ).onDeleteAnnotation( annotation ); }
|
FindAllDmnAssetsQuery extends AbstractFindQuery implements NamedQuery { @Override public Sort getSortOrder() { return new Sort(new SortField(FILE_NAME_FIELD_SORTED, STRING)); } @Inject FindAllDmnAssetsQuery(final FileDetailsResponseBuilder responseBuilder); @Override String getName(); @Override Query toQuery(final Set<ValueIndexTerm> terms); @Override Sort getSortOrder(); @Override ResponseBuilder getResponseBuilder(); @Override void validateTerms(final Set<ValueIndexTerm> queryTerms); static String NAME; }
|
@Test public void testGetSortOrder() { final Sort expected = new Sort(new SortField(FILE_NAME_FIELD_SORTED, STRING)); final Sort actual = query.getSortOrder(); assertEquals(expected, actual); }
|
AnnotationListItem implements AnnotationListItemView.Presenter, IsWidget { @PreDestroy protected void destroy() { for ( AnnotationValuePairListItem item : items ) { dispose( item ); } items.clear(); } AnnotationListItem( ); @Inject AnnotationListItem( AnnotationListItemView view, Instance<AnnotationValuePairListItem> itemInstance ); @Override Widget asWidget( ); void loadAnnotation( Annotation annotation, AnnotationSource annotationSource ); void setDeleteAnnotationHandler( AdvancedAnnotationListEditorView.DeleteAnnotationHandler deleteAnnotationHandler ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); void setCollapseChangeHandler( AdvancedAnnotationListEditorView.CollapseChangeHandler collapseChangeHandler ); boolean isCollapsed( ); void setCollapsed( boolean collapsed ); void setReadonly( boolean readonly ); @Override void onDelete( ); @Override void onCollapseChange( ); }
|
@Test public void testDestroy() { listItem.loadAnnotation( annotation, annotationSource ); listItem.destroy(); for ( AnnotationValuePairListItem valuePairItem : valuePairItems ) { verify( itemInstance, times( 1 ) ).destroy( valuePairItem ); } }
|
AnnotationValuePairListItem implements AnnotationValuePairListItemView.Presenter, IsWidget { public void loadValuePair( final Annotation annotation, final AnnotationValuePairDefinition valuePairDefinition, final AnnotationSource annotationSource ) { this.annotation = annotation; this.valuePairDefinition = valuePairDefinition; view.setValuePairName( valuePairDefinition.getName( ) ); view.setValuePairStringValue( getValuePairStringValue( annotation, valuePairDefinition, annotationSource ) ); if ( valuePairDefinition.getDefaultValue( ) == null ) { view.showRequiredIndicator( true ); } } AnnotationValuePairListItem( ); @Inject AnnotationValuePairListItem( AnnotationValuePairListItemView view ); @Override Widget asWidget( ); void loadValuePair( final Annotation annotation,
final AnnotationValuePairDefinition valuePairDefinition,
final AnnotationSource annotationSource ); void setReadonly( boolean readonly ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); @Override void onEdit( ); @Override void onClear( ); }
|
@Test public void testLoadValuePairWithValueSet( ) { when( annotation.getValue( VALUE_PAIR_NAME ) ).thenReturn( new Object( ) ); when( annotationSource.getValuePairSource( VALUE_PAIR_NAME ) ).thenReturn( VALUE_PAIR_SOURCE_CODE ); listItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); verify( view, times( 1 ) ).setValuePairName( VALUE_PAIR_NAME ); verify( view, times( 1 ) ).setValuePairStringValue( VALUE_PAIR_SOURCE_CODE ); }
@Test public void testLoadValuePairWithValueNotSet( ) { when( annotation.getValue( VALUE_PAIR_NAME ) ).thenReturn( null ); when( annotationSource.getValuePairSource( VALUE_PAIR_NAME ) ).thenReturn( VALUE_PAIR_SOURCE_CODE ); listItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); verify( view, times( 1 ) ).setValuePairName( VALUE_PAIR_NAME ); verify( view, times( 1 ) ).setValuePairStringValue( Constants.INSTANCE.advanced_domain_annotation_list_editor_message_value_not_set( ) ); }
|
AnnotationValuePairListItem implements AnnotationValuePairListItemView.Presenter, IsWidget { @Override public void onEdit( ) { if ( editValuePairHandler != null ) { editValuePairHandler.onEditValuePair( annotation, valuePairDefinition.getName( ) ); } } AnnotationValuePairListItem( ); @Inject AnnotationValuePairListItem( AnnotationValuePairListItemView view ); @Override Widget asWidget( ); void loadValuePair( final Annotation annotation,
final AnnotationValuePairDefinition valuePairDefinition,
final AnnotationSource annotationSource ); void setReadonly( boolean readonly ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); @Override void onEdit( ); @Override void onClear( ); }
|
@Test public void testOnEdit( ) { listItem.setEditValuePairHandler( editValuePairHandler ); listItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); listItem.onEdit( ); verify( editValuePairHandler, times( 1 ) ).onEditValuePair( annotation, VALUE_PAIR_NAME ); }
|
AnnotationValuePairListItem implements AnnotationValuePairListItemView.Presenter, IsWidget { @Override public void onClear( ) { if ( clearValuePairHandler != null ) { clearValuePairHandler.onClearValuePair( annotation, valuePairDefinition.getName( ) ); } } AnnotationValuePairListItem( ); @Inject AnnotationValuePairListItem( AnnotationValuePairListItemView view ); @Override Widget asWidget( ); void loadValuePair( final Annotation annotation,
final AnnotationValuePairDefinition valuePairDefinition,
final AnnotationSource annotationSource ); void setReadonly( boolean readonly ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); @Override void onEdit( ); @Override void onClear( ); }
|
@Test public void testOnClear( ) { listItem.setClearValuePairHandler( clearValuePairHandler ); listItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); listItem.onClear( ); verify( clearValuePairHandler, times( 1 ) ).onClearValuePair( annotation, VALUE_PAIR_NAME ); }
|
AnnotationValuePairListItem implements AnnotationValuePairListItemView.Presenter, IsWidget { public void setReadonly( boolean readonly ) { view.setReadonly( readonly ); } AnnotationValuePairListItem( ); @Inject AnnotationValuePairListItem( AnnotationValuePairListItemView view ); @Override Widget asWidget( ); void loadValuePair( final Annotation annotation,
final AnnotationValuePairDefinition valuePairDefinition,
final AnnotationSource annotationSource ); void setReadonly( boolean readonly ); void setClearValuePairHandler( AdvancedAnnotationListEditorView.ClearValuePairHandler clearValuePairHandler ); void setEditValuePairHandler( AdvancedAnnotationListEditorView.EditValuePairHandler editValuePairHandler ); @Override void onEdit( ); @Override void onClear( ); }
|
@Test public void testSetReadonlyTrue( ) { listItem.setReadonly( true ); verify( view, times( 1 ) ).setReadonly( true ); }
@Test public void testSetReadonlyFalse( ) { listItem.setReadonly( false ); verify( view, times( 1 ) ).setReadonly( false ); }
|
BooleanValuePairEditor implements BooleanValuePairEditorView.Presenter,
ValuePairEditor<Boolean> { @Override public void init( AnnotationValuePairDefinition valuePairDefinition ) { this.valuePairDefinition = valuePairDefinition; view.setValuePairLabel( ValuePairEditorUtil.buildValuePairLabel( valuePairDefinition ) ); view.showValuePairRequiredIndicator( !valuePairDefinition.hasDefaultValue() ); } BooleanValuePairEditor(); BooleanValuePairEditor( BooleanValuePairEditorView view ); @Override Widget asWidget(); @Override void init( AnnotationValuePairDefinition valuePairDefinition ); @Override void setValue( Boolean value ); @Override Boolean getValue( ); @Override boolean isValid(); @Override void clear(); @Override void addEditorHandler( ValuePairEditorHandler editorHandler ); @Override AnnotationValuePairDefinition getValuePairDefinition(); @Override void setErrorMessage( String errorMessage ); @Override void clearErrorMessage(); @Override void showValidateButton( boolean show ); @Override void showValuePairName( boolean show ); @Override void refresh(); @Override void onValueChange(); }
|
@Test public void testEditorLoad() { BooleanValuePairEditor booleanEditor = new BooleanValuePairEditor( view ); AnnotationValuePairDefinition valuePairDefinition = annotationDefinition.getValuePair( "booleanParam1" ); booleanEditor.init( valuePairDefinition ); verify( view, times( 1 ) ).initOptions( options ); verify( view, times( 1 ) ).setValuePairLabel( valuePairDefinition.getName() ); verify( view, times( 1 ) ).showValuePairRequiredIndicator( false ); }
|
MultipleEnumValuePairEditor implements MultipleEnumValuePairEditorView.Presenter,
ValuePairEditor<List<String>> { @Override public void init( AnnotationValuePairDefinition valuePairDefinition ) { this.valuePairDefinition = valuePairDefinition; view.setValuePairLabel( ValuePairEditorUtil.buildValuePairLabel( valuePairDefinition ) ); view.showValuePairRequiredIndicator( !valuePairDefinition.hasDefaultValue() ); initOptionEditors( createOptions( valuePairDefinition.enumValues() ) ); } MultipleEnumValuePairEditor(); MultipleEnumValuePairEditor( MultipleEnumValuePairEditorView view ); @Override Widget asWidget(); @Override void init( AnnotationValuePairDefinition valuePairDefinition ); @Override void clear(); @Override void addEditorHandler( ValuePairEditorHandler editorHandler ); @Override void setValue( List<String> value ); List<String> getValue( ); @Override boolean isValid(); @Override AnnotationValuePairDefinition getValuePairDefinition(); @Override void setErrorMessage( String errorMessage ); @Override void clearErrorMessage(); @Override void showValidateButton( boolean show ); @Override void showValuePairName( boolean show ); @Override void refresh(); }
|
@Test public void testEditorLoad() { MultipleEnumValuePairEditor enumEditor = new MultipleEnumValuePairEditorExtended( view ); AnnotationValuePairDefinition valuePairDefinition = annotationDefinition.getValuePair( "enumArrayParam1" ); enumEditor.init( valuePairDefinition ); verify( view, times( 1 ) ).setValuePairLabel( valuePairDefinition.getName() ); verify( view, times( 1 ) ).showValuePairRequiredIndicator( false ); verify( view, times( 1 ) ).addOptionEditor( optionEditors.get( TestEnums.ENUM1.VALUE1.name() ) ); verify( view, times( 1 ) ).addOptionEditor( optionEditors.get( TestEnums.ENUM1.VALUE2.name() ) ); verify( view, times( 1 ) ).addOptionEditor( optionEditors.get( TestEnums.ENUM1.VALUE3.name() ) ); verify( view, times( 1 ) ).addOptionEditor( optionEditors.get( "{}" ) ); }
|
EnumValuePairEditor implements EnumValuePairEditorView.Presenter,
ValuePairEditor<String> { @Override public void init( AnnotationValuePairDefinition valuePairDefinition ) { this.valuePairDefinition = valuePairDefinition; view.initOptions( createOptionsList( valuePairDefinition.enumValues() ) ); view.setValuePairLabel( ValuePairEditorUtil.buildValuePairLabel( valuePairDefinition ) ); view.showValuePairRequiredIndicator( !valuePairDefinition.hasDefaultValue() ); } EnumValuePairEditor(); EnumValuePairEditor( EnumValuePairEditorView view ); @Override Widget asWidget(); @Override void init( AnnotationValuePairDefinition valuePairDefinition ); @Override void setValue( String value ); String getValue( ); @Override boolean isValid(); @Override void clear(); @Override void addEditorHandler( ValuePairEditorHandler editorHandler ); @Override AnnotationValuePairDefinition getValuePairDefinition(); @Override void setErrorMessage( String errorMessage ); @Override void clearErrorMessage(); @Override void showValidateButton( boolean show ); @Override void showValuePairName( boolean show ); @Override void refresh(); @Override void onValueChange(); }
|
@Test public void testEditorLoad() { EnumValuePairEditor enumEditor = new EnumValuePairEditor( view ); AnnotationValuePairDefinition valuePairDefinition = annotationDefinition.getValuePair( "enumParam1" ); enumEditor.init( valuePairDefinition ); verify( view, times( 1 ) ).initOptions( enumOptions ); verify( view, times( 1 ) ).setValuePairLabel( valuePairDefinition.getName() ); verify( view, times( 1 ) ).showValuePairRequiredIndicator( false ); }
|
MainDataObjectFieldEditor extends FieldEditor implements MainDataObjectFieldEditorView.Presenter { @Override protected void loadDataObjectField(DataObject dataObject, ObjectProperty objectField) { clear(); setReadonly(true); if (dataObject != null && objectField != null) { this.dataObject = dataObject; this.objectField = objectField; initTypeList(); view.setName(getObjectField().getName()); Annotation annotation = objectField.getAnnotation(MainDomainAnnotations.LABEL_ANNOTATION); if (annotation != null) { view.setLabel(AnnotationValueHandler.getStringValue(annotation, MainDomainAnnotations.VALUE_PARAM)); } annotation = objectField.getAnnotation(MainDomainAnnotations.DESCRIPTION_ANNOTATION); if (annotation != null) { view.setDescription(AnnotationValueHandler.getStringValue(annotation, MainDomainAnnotations.VALUE_PARAM)); } setReadonly(getContext() == null || getContext().isReadonly()); } else { initTypeList(); } } @Inject MainDataObjectFieldEditor(MainDataObjectFieldEditorView view,
DomainHandlerRegistry handlerRegistry,
Event<DataModelerEvent> dataModelerEvent,
DataModelCommandBuilder commandBuilder,
ValidatorService validatorService,
Caller<DataModelerService> modelerService,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer); void onContextChange(DataModelerContext context); @Override String getName(); @Override String getDomainName(); void setReadonly(boolean readonly); @Override Widget asWidget(); @Override void onNameChange(); @Override void onLabelChange(); @Override void onDescriptionChange(); @Override void onTypeChange(); @Override void onTypeMultipleChange(); void refreshTypeList(boolean keepSelection); void clear(); }
|
@Test public void loadDataObjectFieldTest() { MainDataObjectFieldEditor fieldEditor = createFieldEditor(); DataObject dataObject = context.getDataObject(); ObjectProperty field = dataObject.getProperty("field1"); context.setObjectProperty(field); fieldEditor.onContextChange(context); verify(view, times(1)).setName(field.getName()); verify(view, times(1)).setLabel(AnnotationValueHandler.getStringValue(field, Label.class.getName(), "value")); verify(view, times(1)).setDescription(AnnotationValueHandler.getStringValue(field, Description.class.getName(), "value")); verify(view, times(1)).initTypeList(anyList(), eq(field.getClassName()), eq(false)); assertFalse(fieldEditor.isReadonly()); }
|
MainDataObjectEditor extends ObjectEditor implements MainDataObjectEditorView.Presenter { @Override protected void loadDataObject(DataObject dataObject) { clear(); setReadonly(true); if (dataObject != null) { this.dataObject = dataObject; view.setName(dataObject.getName()); Annotation annotation = dataObject.getAnnotation(MainDomainAnnotations.LABEL_ANNOTATION); if (annotation != null) { view.setLabel(AnnotationValueHandler.getStringValue(annotation, MainDomainAnnotations.VALUE_PARAM)); } annotation = dataObject.getAnnotation(MainDomainAnnotations.DESCRIPTION_ANNOTATION); if (annotation != null) { view.setDescription(AnnotationValueHandler.getStringValue(annotation, MainDomainAnnotations.VALUE_PARAM)); } view.setPackageName(dataObject.getPackageName()); initSuperClassList(false); setReadonly(getContext() == null || getContext().isReadonly()); } } @Inject MainDataObjectEditor(MainDataObjectEditorView view,
DomainHandlerRegistry handlerRegistry,
Event<DataModelerEvent> dataModelerEvent,
DataModelCommandBuilder commandBuilder,
ValidatorService validatorService,
Caller<DataModelerService> modelerService,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer); @Override Widget asWidget(); @Override String getName(); @Override String getDomainName(); void onContextChange(DataModelerContext context); void refreshTypeList(boolean keepSelection); void setReadonly(boolean readonly); @Override void onNameChange(); @Override void onLabelChange(); @Override void onDescriptionChange(); @Override void onSuperClassChange(); @Override void onPackageAdded(); @Override void onPackageChange(); void doPackageChange(String packageName); void clear(); }
|
@Test public void loadDataObjectTest() { MainDataObjectEditor objectEditor = createObjectEditor(); objectEditor.onContextChange(context); DataObject dataObject = context.getDataObject(); verify(view, times(1)).setName(dataObject.getName()); verify(view, times(1)).setPackageName(dataObject.getPackageName()); verify(view, times(1)).initSuperClassList(anyList(), eq(dataObject.getSuperClassName())); verify(view, times(1)).setLabel(AnnotationValueHandler.getStringValue(dataObject, Label.class.getName(), "value")); verify(view, times(1)).setDescription(AnnotationValueHandler.getStringValue(dataObject, Description.class.getName(), "value")); assertFalse(objectEditor.isReadonly()); }
|
PackageSelector implements
PackageSelectorView.Presenter,
IsWidget { public void setContext( DataModelerContext context ) { this.context = context; initList( null, true ); } @Inject PackageSelector( PackageSelectorView view ); @Override Widget asWidget(); @Override void onPackageChange(); @Override void onNewPackage(); void enableCreatePackage( boolean enable ); void setEnabled( boolean enabled ); boolean isValueSelected(); String getPackage(); String getNewPackage(); DataModelerContext getContext(); void setContext( DataModelerContext context ); void setCurrentPackage( String currentPackage ); void clear(); void addPackageSelectorHandler( PackageSelectorView.PackageSelectorHandler handler ); }
|
@Test public void loadEditorTest() { DataModelerContext context = createContext(); List<Pair<String, String>> expectedPackageList = expectedPackageList(); PackageSelector packageSelector = new PackageSelector( view ); packageSelector.setContext( context ); verify( view, times( 1 ) ).initPackageList( expectedPackageList, null, true ); }
|
NewPackagePopup implements NewPackagePopupView.Presenter { @Override public void onValueTyped() { view.setPackageName(toLowerCase(view.getPackageName())); } @Inject NewPackagePopup(NewPackagePopupView view,
ValidatorService validatorService); String getPackageName(); @Override void onCreatePackage(); @Override void onValueTyped(); void show(Command afterAddCommand); }
|
@Test public void testOnValueTyped() { String value1 = "VALUE1"; String value2 = "ValuE2"; String value3 = "value3"; when(view.getPackageName()).thenReturn(value1); newPackagePopup.onValueTyped(); verify(view, times(1)).setPackageName(value1.toLowerCase()); when(view.getPackageName()).thenReturn(value2); newPackagePopup.onValueTyped(); verify(view, times(1)).setPackageName(value2.toLowerCase()); when(view.getPackageName()).thenReturn(value3); newPackagePopup.onValueTyped(); verify(view, times(1)).setPackageName(value3.toLowerCase()); }
|
DataModellerDocksHandler extends AbstractWorkbenchDocksHandler { public void onContextChange(@Observes DataModelerWorkbenchContextChangeEvent contextEvent) { DataModelerContext newContext = dataModelerWBContext.getActiveContext(); boolean doRefresh; if (newContext == null) { doRefresh = true; dataModelerIsHidden = true; } else if (!newContext.equals(lastActiveContext) || (newContext.equals(lastActiveContext) && !newContext.getEditionMode().equals(lastEditionMode))) { doRefresh = true; dataModelerIsHidden = !isGraphicMode(newContext); lastEditionMode = newContext.getEditionMode(); } else { doRefresh = false; } lastActiveContext = newContext; refreshDocks(doRefresh, dataModelerIsHidden); } @Inject DataModellerDocksHandler(SessionInfo sessionInfo,
AuthorizationManager authorizationManager,
DataModelerWorkbenchContext dataModelerWBContext); boolean isGraphicMode(DataModelerContext context); @Override Collection<UberfireDock> provideDocks(String perspectiveIdentifier); void onContextChange(@Observes DataModelerWorkbenchContextChangeEvent contextEvent); void onDataModelerWorkbenchFocusEvent(@Observes DataModelerWorkbenchFocusEvent event); }
|
@Test public void testChangeDataModelerContextSameContextSourceMode() { testSetDataModelerFocusEventWithPlanner(); originalContext.setEditionMode(DataModelerContext.EditionMode.SOURCE_MODE); handler.onContextChange(new DataModelerWorkbenchContextChangeEvent()); assertTrue(handler.shouldRefreshDocks()); assertTrue(handler.shouldDisableDocks()); verify(command, times(2)).execute(); }
|
DataModelerScreenPresenter extends KieEditor<String> { protected void save() { validationService.call(checkMessages -> { if (((List<ValidationMessage>) checkMessages).isEmpty()) { checkDirtyAndSaveFile(); } else { validationPopup.showSaveValidationMessages(() -> checkDirtyAndSaveFile(), () -> { }, (List<ValidationMessage>) checkMessages); } }).validateForSave(versionRecordManager.getPathToLatest(), context.getDataObject()); } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void onSaveValidationFailedTest() { when(validationService.validateForSave(any(Path.class), any(DataObject.class))).thenReturn(Arrays.asList(new ValidationMessage())); presenter.context = mock(DataModelerContext.class); presenter.save(); verify(savePopUpPresenter, never()).show(any(Path.class), any(ParameterizedCommand.class)); verify(validationPopup, times(1)).showSaveValidationMessages(any(Command.class), any(Command.class), anyListOf(ValidationMessage.class)); }
@Test public void onSaveValidationSucceededTest() { when(validationService.validateForSave(any(Path.class), any(DataObject.class))).thenReturn(Collections.emptyList()); presenter.context = mock(DataModelerContext.class); presenter.save(); verify(savePopUpPresenter, times(1)).show(any(Path.class), any(ParameterizedCommand.class)); verify(validationPopup, never()).showCopyValidationMessages(any(Command.class), any(Command.class), anyListOf(ValidationMessage.class)); }
@Test public void onSaveWithPackageChangeTest() { when(validationService.validateForSave(any(Path.class), any(DataObject.class))).thenReturn(Collections.emptyList()); presenter.context = mock(DataModelerContext.class); when(presenter.context.getDataObject()).thenReturn(testObject1); when(presenter.context.isEditorChanged()).thenReturn(true); when(presenter.context.getEditorModelContent()).thenReturn(mock(EditorModelContent.class)); when(presenter.context.getEditorModelContent().getOriginalPackageName()).thenReturn("org.test.original"); presenter.save(); verify(view).showYesNoCancelPopup(anyString(), anyString(), any(Command.class), anyString(), eq(ButtonType.PRIMARY), any(Command.class), anyString(), eq(ButtonType.DANGER)); }
@Test public void onSaveWithRenameTest() { presenter.context = mock(DataModelerContext.class); when(validationService.validateForSave(any(Path.class), any(DataObject.class))).thenReturn(Collections.emptyList()); when(presenter.context.getDataObject()).thenReturn(testObject1); when(presenter.context.isEditorChanged()).thenReturn(true); when(presenter.context.getEditorModelContent()).thenReturn(mock(EditorModelContent.class)); when(presenter.context.getEditorModelContent().getOriginalPackageName()).thenReturn(testObject1.getPackageName()); final ObservablePath mockPath = mock(ObservablePath.class); when(versionRecordManager.getPathToLatest()).thenReturn(mockPath); when(mockPath.getFileName()).thenReturn("testCurrentFile.java"); presenter.save(); verify(view).showYesNoCancelPopup(anyString(), anyString(), any(Command.class), anyString(), eq(ButtonType.PRIMARY), any(Command.class), anyString(), eq(ButtonType.DANGER)); }
@Test public void testSaveSuccessCallbackWithPathChange() { final String commitMessage = "testCommitMessage"; final GenerationResult result = setupSave(); when(modelerService.saveSource(eq("testSource"), any(Path.class), eq(testObject1), any(Metadata.class), eq(commitMessage), any(String.class), any(String.class))).thenReturn(result); presenter.save(); verify(view).showYesNoCancelPopup(anyString(), anyString(), yesCommandCaptor.capture(), anyString(), eq(ButtonType.PRIMARY), any(Command.class), anyString(), eq(ButtonType.DANGER)); yesCommandCaptor.getValue().execute(); verify(savePopUpPresenter).show(any(Path.class), parameterizedCommandCaptor.capture()); parameterizedCommandCaptor.getValue().execute(commitMessage); verify(dataModelerEvent, times(2)) .fire(any(DataModelStatusChangeEvent.class)); verify(versionRecordManager).reloadVersions(any(Path.class)); }
@Test public void testSaveSuccessCallbackRejectingPathChange() { final String commitMessage = "testCommitMessage"; final GenerationResult result = setupSave(); when(modelerService.saveSource(eq("testSource"), any(Path.class), eq(testObject1), any(Metadata.class), eq(commitMessage))).thenReturn(result); presenter.save(); verify(view).showYesNoCancelPopup(anyString(), anyString(), any(Command.class), anyString(), eq(ButtonType.PRIMARY), noCommandCaptor.capture(), anyString(), eq(ButtonType.DANGER)); noCommandCaptor.getValue().execute(); verify(savePopUpPresenter).show(any(Path.class), parameterizedCommandCaptor.capture()); parameterizedCommandCaptor.getValue().execute(commitMessage); verify(dataModelerEvent, times(2)) .fire(any(DataModelStatusChangeEvent.class)); verify(versionRecordManager).reloadVersions(any(Path.class)); }
|
DataModelerScreenPresenter extends KieEditor<String> { public void onSafeDelete() { if (context.getEditorModelContent().getOriginalClassName() != null) { final String className = context.getEditorModelContent().getOriginalClassName(); showAssetUsagesDisplayer.showAssetUsages(Constants.INSTANCE.modelEditor_confirm_deletion_of_used_class(className), versionRecordManager.getCurrentPath(), className, ResourceType.JAVA, () -> onDelete(versionRecordManager.getPathToLatest()), () -> { }); } else { onDelete(versionRecordManager.getPathToLatest()); } } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void onSafeDeleteWithOriginalClassName() { loadFileSuccessfulTest(false); presenter.onSafeDelete(); verify(showAssetUsages).showAssetUsages(anyString(), any(), anyString(), any(), any(), any()); verify(validationService, never()).validateForDelete(any(), any()); verify(deletePopUpPresenter, never()).show(any()); }
@Test public void onSafeDeleteWithoutOriginalClassName() { loadFileSuccessfulTest(false); presenter.context.getEditorModelContent().setOriginalClassName(null); presenter.onSafeDelete(); verify(showAssetUsages, never()).showAssetUsages(anyString(), any(), anyString(), any(), any(), any()); verify(validationService).validateForDelete(any(), any()); verify(deletePopUpPresenter).show(any(JavaAssetUpdateValidator.class), any()); }
|
DataModelerScreenPresenter extends KieEditor<String> { public void onSafeRename() { if (context.getEditorModelContent().getOriginalClassName() != null) { final String className = context.getEditorModelContent().getOriginalClassName(); showAssetUsagesDisplayer.showAssetUsages(Constants.INSTANCE.modelEditor_confirm_renaming_of_used_class(className), versionRecordManager.getCurrentPath(), className, ResourceType.JAVA, () -> rename(), () -> { }); } else { rename(); } } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void onSafeRenameWithOriginalClassName() { loadFileSuccessfulTest(false); presenter.onSafeRename(); verify(showAssetUsages).showAssetUsages(anyString(), any(), anyString(), any(), any(), any()); verify(renamePopUpPresenter, never()).show(any(Path.class), any(JavaAssetUpdateValidator.class), any(CommandWithFileNameAndCommitMessage.class)); }
@Test public void onSafeRenameWithoutOriginalClassName() { loadFileSuccessfulTest(false); presenter.context.getEditorModelContent().setOriginalClassName(null); presenter.onSafeRename(); verify(showAssetUsages, never()).showAssetUsages(anyString(), any(), anyString(), any(), any(), any()); verify(renamePopUpPresenter).show(any(Path.class), any(JavaAssetUpdateValidator.class), any(CommandWithFileNameAndCommitMessage.class)); }
|
DataModelerScreenPresenter extends KieEditor<String> { void onCopy() { validationService.call(checkMessages -> { if (((List<ValidationMessage>) checkMessages).isEmpty()) { showCopyPopup(); } else { validationPopup.showCopyValidationMessages(() -> showCopyPopup(), () -> { }, ((List<ValidationMessage>) checkMessages)); } }).validateForCopy(versionRecordManager.getPathToLatest(), context.getDataObject()); } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void onCopyValidationSucceededTest() { when(validationService.validateForCopy(any(Path.class), any(DataObject.class))).thenReturn(Collections.emptyList()); presenter.context = mock(DataModelerContext.class); presenter.onCopy(); verify(copyPopUpPresenter, times(1)).show(any(Path.class), any(JavaAssetUpdateValidator.class), any(CommandWithFileNameAndCommitMessage.class)); verify(validationPopup, never()).showCopyValidationMessages(any(Command.class), any(Command.class), anyListOf(ValidationMessage.class)); }
@Test public void onCopyValidationFailedTest() { when(validationService.validateForCopy(any(Path.class), any(DataObject.class))).thenReturn(Arrays.asList(new ValidationMessage())); presenter.context = mock(DataModelerContext.class); presenter.onCopy(); verify(copyPopUpPresenter, never()).show(any(Path.class), any(JavaAssetUpdateValidator.class), any(CommandWithFileNameAndCommitMessage.class)); verify(validationPopup, times(1)).showCopyValidationMessages(any(Command.class), any(Command.class), anyListOf(ValidationMessage.class)); }
@Test public void onCopyWithTargetPathTest() { prepareOnCopyTest(); presenter.onCopy(); verify(copyPopUpPresenter, times(1)).show(pathArgumentCaptor.capture(), validatorArgumentCaptor.capture(), commandWithFileNameArgumentCaptor.capture()); Path targetPath = mock(Path.class); when(copyPopUpPresenterView.getTargetPath()).thenReturn(targetPath); commandWithFileNameArgumentCaptor.getValue().execute(commitMessage); verify(modelerService, times(1)).copy(path, FILE_NAME, null, targetPath, COMMIT_MESSAGE, true); }
@Test public void onCopyWithNoTargetPathTest() { prepareOnCopyTest(); presenter.onCopy(); verify(copyPopUpPresenter, times(1)).show(pathArgumentCaptor.capture(), validatorArgumentCaptor.capture(), commandWithFileNameArgumentCaptor.capture()); when(copyPopUpPresenterView.getTargetPath()).thenReturn(null); commandWithFileNameArgumentCaptor.getValue().execute(commitMessage); verify(modelerService, times(1)).copy(path, FILE_NAME, COMMIT_MESSAGE, true); }
|
DataModelerScreenPresenter extends KieEditor<String> { @Override protected Promise<Void> makeMenuBar() { if (!workbenchContext.getActiveWorkspaceProject().isPresent()) { return promises.resolve(); } final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder.addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(() -> onCopy()) .addRename(() -> onSafeRename()) .addDelete(() -> onSafeDelete()); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder.addValidate(getValidateCommand()) .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void testMakeMenuBar() { final DataModelerScreenPresenter presenter = spy(this.presenter); doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); presenter.makeMenuBar(); verify(fileMenuBuilder).addSave(any(MenuItem.class)); verify(fileMenuBuilder).addCopy(any(Command.class)); verify(fileMenuBuilder).addRename(any(Command.class)); verify(fileMenuBuilder).addDelete(any(Command.class)); verify(fileMenuBuilder).addNewTopLevelMenu(alertsButtonMenuItem); verify(presenter).addDownloadMenuItem(fileMenuBuilder); }
@Test public void testMakeMenuBarWithoutUpdateProjectPermission() { doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(false)).when(projectController).canUpdateProject(any()); presenter.makeMenuBar(); verify(fileMenuBuilder, never()).addSave(any(MenuItem.class)); verify(fileMenuBuilder, never()).addCopy(any(Command.class)); verify(fileMenuBuilder, never()).addRename(any(Command.class)); verify(fileMenuBuilder, never()).addDelete(any(Command.class)); verify(fileMenuBuilder).addNewTopLevelMenu(alertsButtonMenuItem); }
|
AddRelationRowCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler handler) { return new AbstractCanvasCommand() { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler handler) { int columnIndex = 0; uiModel.insertRow(uiRowIndex, uiModelRow); uiModelMapper.fromDMNModel(uiRowIndex, columnIndex++); for (int ii = 0; ii < relation.getColumn().size(); ii++) { uiModelMapper.fromDMNModel(uiRowIndex, columnIndex++); } updateRowNumbers(); updateParentInformation(); canvasOperation.execute(); return CanvasCommandResultBuilder.SUCCESS; } @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler handler) { final int rowIndex = uiModel.getRows().indexOf(uiModelRow); uiModel.deleteRow(rowIndex); updateRowNumbers(); updateParentInformation(); canvasOperation.execute(); return CanvasCommandResultBuilder.SUCCESS; } }; } AddRelationRowCommand(final Relation relation,
final List row,
final GridData uiModel,
final GridRow uiModelRow,
final int uiRowIndex,
final RelationUIModelMapper uiModelMapper,
final org.uberfire.mvp.Command canvasOperation); void updateRowNumbers(); void updateParentInformation(); }
|
@Test public void testCanvasCommandAllow() { final Command<AbstractCanvasHandler, CanvasViolation> c = command.newCanvasCommand(handler); assertEquals(CanvasCommandResultBuilder.SUCCESS, c.allow(handler)); }
|
DataModelerScreenPresenter extends KieEditor<String> { @Override public void showDocks() { super.showDocks(); showDataModellerDocks(); } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void testShowDocks() { presenter.showDocks(); verify(docks).show(); verify(dataModelerFocusEvent).fire(any()); }
|
DataModelerScreenPresenter extends KieEditor<String> { @Override public void hideDocks() { super.hideDocks(); if (context != null) { dataModelerFocusEvent.fire(new DataModelerWorkbenchFocusEvent().lostFocus()); } } @Inject DataModelerScreenPresenter(DataModelerScreenView baseView,
SessionInfo sessionInfo); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartTitleDecoration IsWidget getTitle(); @WorkbenchPartView IsWidget getView(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void showDocks(); @Override void hideDocks(); @OnMayClose boolean onMayClose(); @OnClose @Override void onClose(); void onSafeDelete(); void onSafeRename(); DataModel getDataModel(); String getSource(); void setSource(String source); @Override void onSourceTabSelected(); @Override void onOverviewSelected(); @Override void onEditTabSelected(); static final String EDITOR_ID; }
|
@Test public void testHideDocksNoContext() { presenter.hideDocks(); verify(docks).hide(); verify(dataModelerFocusEvent, never()).fire(any()); }
@Test public void testHideDocksHasContext() { presenter.context = mock(DataModelerContext.class); presenter.hideDocks(); verify(docks).hide(); verify(dataModelerFocusEvent).fire(any()); }
|
RemovePropertyCommand extends AbstractDataModelCommand { @Override public void execute() { if (dataObject != null) { ObjectProperty property = dataObject.getProperty(propertyName); if (property != null) { dataObject.removeProperty(propertyName); notifyChange(new DataObjectFieldDeletedEvent(getContext().getContextId(), getSource(), getDataObject(), property)); } } } RemovePropertyCommand(final DataModelerContext context,
final String source,
final DataObject dataObject,
final String propertyName,
final DataModelChangeNotifier notifier); @Override void execute(); }
|
@Test public void execute() { DataObject dataObject = new DataObjectImpl("org.test", "TestDataObject"); dataObject.addProperty(new ObjectPropertyImpl("testProperty", Integer.class.getName(), false)); DataModelChangeNotifier notifier = mock(DataModelChangeNotifier.class); RemovePropertyCommand command = new RemovePropertyCommand(new DataModelerContext(), "source", dataObject, "testProperty", notifier); command.execute(); assertNull(dataObject.getProperty("testProperty")); verify(notifier, times(1)).notifyChange(any(DataObjectFieldDeletedEvent.class)); }
|
ProjectClassList implements IsWidget,
ProjectClassListView.Presenter { @Override public void onRemoveClass( ClassRow classRow ) { classes.remove( classRow ); setClasses( classes ); } ProjectClassList(); @Inject ProjectClassList( ProjectClassListView view ); @Override Widget asWidget(); void setClasses( List<ClassRow> classes ); List<ClassRow> getClasses(); void setNewClassHelpMessage( String helpMessage ); void setNewClassName( String newClassName ); @Override void onLoadClasses(); @Override void onLoadClass(); @Override void onClassNameChange(); @Override void onRemoveClass( ClassRow classRow ); @Override void addLoadClassesHandler( ProjectClassListView.LoadClassesHandler loadClassesHandler ); void setReadOnly( boolean readOnly ); void redraw(); }
|
@Test public void testOnRemoveClass() { final ProjectClassListView.LoadClassesHandler handler = new ProjectClassListView.LoadClassesHandler() { @Override public void onLoadClasses() { List<ClassRow> classes = new ArrayList<ClassRow>(); classes.add(classRow1); classes.add(classRow2); presenter.setClasses(classes); } @Override public void onLoadClass(String className) { } }; presenter.addLoadClassesHandler(handler); presenter.onLoadClasses(); verify(view, times(1)).redraw(); assertThat(presenter.getClasses()).hasSize(2); presenter.onRemoveClass(classRow1); verify(view, times(2)).redraw(); assertThat(presenter.getClasses()).hasSize(1); assertThat(presenter.getClasses()).doesNotContain(classRow1); presenter.onRemoveClass(classRow2); verify(view, times(3)).redraw(); assertThat(presenter.getClasses()).hasSize(0); }
|
ProjectClassList implements IsWidget,
ProjectClassListView.Presenter { @Override public void onLoadClass() { view.setNewClassHelpMessage( null ); String newClassName = DataModelerUtils.nullTrim( view.getNewClassName() ); if ( newClassName == null ) { view.setNewClassHelpMessage( Constants.INSTANCE.project_class_list_class_name_empty_message() ); } else if ( loadClassesHandler != null ) { loadClassesHandler.onLoadClass( newClassName ); } else { if ( classes == null ) { classes = new ArrayList<ClassRow>( ); } classes.add( new ClassRowImpl( newClassName ) ); setClasses( classes ); } } ProjectClassList(); @Inject ProjectClassList( ProjectClassListView view ); @Override Widget asWidget(); void setClasses( List<ClassRow> classes ); List<ClassRow> getClasses(); void setNewClassHelpMessage( String helpMessage ); void setNewClassName( String newClassName ); @Override void onLoadClasses(); @Override void onLoadClass(); @Override void onClassNameChange(); @Override void onRemoveClass( ClassRow classRow ); @Override void addLoadClassesHandler( ProjectClassListView.LoadClassesHandler loadClassesHandler ); void setReadOnly( boolean readOnly ); void redraw(); }
|
@Test public void testOnLoadClassWithClassAndNotNullHandler() { when(view.getNewClassName()).thenReturn("NewClassName"); presenter.onLoadClass(); verify(mockLoadClassesHandler).onLoadClass("NewClassName"); }
|
PersistenceUnitPropertyGrid implements IsWidget,
PersistenceUnitPropertyGridView.Presenter { public void setProperties( List<PropertyRow> properties ) { this.properties = properties; dataProvider.getList().clear(); if ( properties != null ) { dataProvider.getList().addAll( properties ); } } PersistenceUnitPropertyGrid(); @Inject PersistenceUnitPropertyGrid( PersistenceUnitPropertyGridView view ); @Override Widget asWidget(); void setProperties( List<PropertyRow> properties ); List<PropertyRow> getProperties(); @Override void onAddProperty(); @Override void onRemoveProperty( PropertyRow propertyRow ); void setReadOnly( boolean readOnly ); void redraw(); }
|
@Test public void testSetProperties() { List<PropertyRow> properties = new ArrayList<PropertyRow>( ); properties.add( propertyRow1 ); properties.add( propertyRow2 ); properties.add( propertyRow3 ); presenter.setProperties( properties ); assertEquals( properties, presenter.getProperties() ); assertEquals( properties, dataProvider.getList() ); }
|
PersistenceUnitPropertyGrid implements IsWidget,
PersistenceUnitPropertyGridView.Presenter { @Override public void onRemoveProperty( PropertyRow propertyRow ) { if ( properties != null ) { properties.remove( propertyRow ); } setProperties( properties ); } PersistenceUnitPropertyGrid(); @Inject PersistenceUnitPropertyGrid( PersistenceUnitPropertyGridView view ); @Override Widget asWidget(); void setProperties( List<PropertyRow> properties ); List<PropertyRow> getProperties(); @Override void onAddProperty(); @Override void onRemoveProperty( PropertyRow propertyRow ); void setReadOnly( boolean readOnly ); void redraw(); }
|
@Test public void testOnRemoveProperty() { List<PropertyRow> properties = new ArrayList<PropertyRow>( ); properties.add( propertyRow1 ); properties.add( propertyRow2 ); properties.add( propertyRow3 ); presenter.setProperties( properties ); presenter.onRemoveProperty( propertyRow1 ); assertEquals( 2, presenter.getProperties().size() ); assertEquals( 2, dataProvider.getList().size() ); assertFalse( presenter.getProperties().contains( propertyRow1 ) ); assertFalse( dataProvider.getList().contains( propertyRow1 ) ); }
|
PersistenceUnitPropertyGrid implements IsWidget,
PersistenceUnitPropertyGridView.Presenter { @Override public void onAddProperty() { String propertyName = view.getNewPropertyName(); String propertyValue = view.getNewPropertyValue(); if ( properties == null ) { properties = new ArrayList<PropertyRow>( ); } properties.add( new PropertyRowImpl( propertyName, propertyValue ) ); setProperties( properties ); view.setNewPropertyName( "" ); view.setNewPropertyValue( "" ); } PersistenceUnitPropertyGrid(); @Inject PersistenceUnitPropertyGrid( PersistenceUnitPropertyGridView view ); @Override Widget asWidget(); void setProperties( List<PropertyRow> properties ); List<PropertyRow> getProperties(); @Override void onAddProperty(); @Override void onRemoveProperty( PropertyRow propertyRow ); void setReadOnly( boolean readOnly ); void redraw(); }
|
@Test public void testOnAddProperty() { when ( view.getNewPropertyName() ).thenReturn( "newPropertyName" ); when ( view.getNewPropertyValue() ).thenReturn( "newPropertyValue" ); presenter.onAddProperty(); verify( view , times( 1 ) ).getNewPropertyName(); verify( view , times( 1 ) ).getNewPropertyValue(); assertEquals( 1, presenter.getProperties().size() ); assertEquals( 1, dataProvider.getList().size() ); assertEquals( "newPropertyName", presenter.getProperties().get( 0 ).getName() ); assertEquals( "newPropertyValue", presenter.getProperties().get( 0 ).getValue() ); }
|
AddRelationColumnCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler handler) { return new AbstractGraphCommand() { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext gce) { return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext gce) { relation.getComponentWidths().add(uiColumnIndex, null); final int iiIndex = uiColumnIndex - RelationUIModelMapperHelper.ROW_INDEX_COLUMN_COUNT; relation.getColumn().add(iiIndex, informationItem); informationItem.getName().setValue(name); relation.getRow().forEach(row -> { final LiteralExpression le = new LiteralExpression(); final HasExpression hasExpression = HasExpression.wrap(row, le); row.getExpression().add(iiIndex, hasExpression); le.setParent(row); }); informationItem.setParent(relation); return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext gce) { relation.getComponentWidths().remove(uiColumnIndex); final int columnIndex = relation.getColumn().indexOf(informationItem); relation.getRow().forEach(row -> row.getExpression().remove(columnIndex)); relation.getColumn().remove(informationItem); return GraphCommandResultBuilder.SUCCESS; } }; } AddRelationColumnCommand(final Relation relation,
final InformationItem informationItem,
final GridData uiModel,
final Supplier<RelationColumn> uiModelColumnSupplier,
final int uiColumnIndex,
final RelationUIModelMapper uiModelMapper,
final org.uberfire.mvp.Command executeCanvasOperation,
final org.uberfire.mvp.Command undoCanvasOperation); void updateParentInformation(); }
|
@Test public void testGraphCommandAllow() { final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.allow(gce)); }
@Test public void testGraphCommandExecuteWithRows() { relation.getRow().add(new List()); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(1, relation.getColumn().size()); assertEquals(informationItem, relation.getColumn().get(0)); assertEquals(RelationDefaultValueUtilities.PREFIX + "1", informationItem.getName().getValue()); assertEquals(1, relation.getRow().size()); assertEquals(1, relation.getRow().get(0).getExpression().size()); assertTrue(relation.getRow().get(0).getExpression().get(0).getExpression() instanceof LiteralExpression); assertEquals(relation, informationItem.getParent()); assertEquals(relation.getRow().get(0), relation.getRow().get(0).getExpression().get(0).getExpression().getParent()); }
@Test public void testGraphCommandExecuteWithExistingColumn_InsertBefore() { final InformationItem existingInformationItem = new InformationItem(); relation.getColumn().add(existingInformationItem); final List row = new List(); relation.getRow().add(row); final LiteralExpression existingLiteralExpression = new LiteralExpression(); row.getExpression().add(0, HasExpression.wrap(row, existingLiteralExpression)); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(2, relation.getColumn().size()); assertEquals(informationItem, relation.getColumn().get(0)); assertEquals(RelationDefaultValueUtilities.PREFIX + "1", informationItem.getName().getValue()); assertEquals(existingInformationItem, relation.getColumn().get(1)); assertEquals(1, relation.getRow().size()); assertEquals(2, relation.getRow().get(0).getExpression().size()); assertTrue(relation.getRow().get(0).getExpression().get(0).getExpression() instanceof LiteralExpression); assertEquals(existingLiteralExpression, relation.getRow().get(0).getExpression().get(1).getExpression()); assertEquals(relation, informationItem.getParent()); assertEquals(relation.getRow().get(0), relation.getRow().get(0).getExpression().get(0).getExpression().getParent()); }
@Test public void testGraphCommandExecuteWithExistingColumn_InsertMiddle() { makeCommand(2); final InformationItem existingInformationItemFirst = new InformationItem(); relation.getColumn().add(existingInformationItemFirst); final InformationItem existingInformationItemLast = new InformationItem(); relation.getColumn().add(existingInformationItemLast); final List row = new List(); relation.getRow().add(row); final LiteralExpression existingLiteralExpressionFirst = new LiteralExpression(); final LiteralExpression existingLiteralExpressionLast = new LiteralExpression(); row.getExpression().add(HasExpression.wrap(row, existingLiteralExpressionFirst)); row.getExpression().add(HasExpression.wrap(row, existingLiteralExpressionLast)); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(3, relation.getColumn().size()); assertEquals(existingInformationItemFirst, relation.getColumn().get(0)); assertEquals(informationItem, relation.getColumn().get(1)); assertEquals(RelationDefaultValueUtilities.PREFIX + "1", informationItem.getName().getValue()); assertEquals(existingInformationItemLast, relation.getColumn().get(2)); assertEquals(1, relation.getRow().size()); assertEquals(3, relation.getRow().get(0).getExpression().size()); assertEquals(existingLiteralExpressionFirst, relation.getRow().get(0).getExpression().get(0).getExpression()); assertTrue(relation.getRow().get(0).getExpression().get(1).getExpression() instanceof LiteralExpression); assertEquals(existingLiteralExpressionLast, relation.getRow().get(0).getExpression().get(2).getExpression()); assertEquals(relation, informationItem.getParent()); assertEquals(relation.getRow().get(0), relation.getRow().get(0).getExpression().get(1).getExpression().getParent()); }
@Test public void testGraphCommandExecuteWithNoRows() { final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(1, relation.getColumn().size()); assertEquals(informationItem, relation.getColumn().get(0)); assertEquals(RelationDefaultValueUtilities.PREFIX + "1", informationItem.getName().getValue()); assertEquals(0, relation.getRow().size()); assertEquals(relation, informationItem.getParent()); }
@Test public void testGraphCommandUndoWithRows() { relation.getRow().add(new List()); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(GraphCommandResultBuilder.SUCCESS, c.undo(gce)); assertEquals(0, relation.getColumn().size()); assertEquals(1, relation.getRow().size()); assertEquals(0, relation.getRow().get(0).getExpression().size()); }
@Test public void testGraphCommandUndoWithNoRows() { final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(GraphCommandResultBuilder.SUCCESS, c.execute(gce)); assertEquals(GraphCommandResultBuilder.SUCCESS, c.undo(gce)); assertEquals(0, relation.getColumn().size()); assertEquals(0, relation.getRow().size()); }
|
DataModelHelper { public Boolean isAssignableFrom(String offspringCandidate, String parentCandidate) { if (offspringCandidate == null || offspringCandidate.length() == 0 || parentCandidate == null || parentCandidate.length() == 0 || offspringCandidate.equals(parentCandidate)) return false; Set<String> candidatesOffspring = offspringMap.get(offspringCandidate); boolean candidateHasOffspring = candidatesOffspring != null && candidatesOffspring.size() > 0; if (candidateHasOffspring) { if (candidatesOffspring.contains(parentCandidate)) return false; for (String newOffspringCandidate : candidatesOffspring) { if (!isAssignableFrom(newOffspringCandidate, parentCandidate)) return false; } } return true; } DataModelHelper( String contextId ); Collection<String> getDataObjectReferences( String className ); String getObjectLabelByClassName(String className); List<String> getClassList(); Map<String, String> getLabelledClassMap(); Map <String, PropertyType> getOrderedBaseTypes(); void dataModelChanged(DataModelerValueChangeEvent changeEvent); void dataObjectReferenced(String objectClassName, String subjectClassName); void dataObjectUnReferenced(String objectClassName, String subjectClassName); void dataObjectExtended(String parentClassName, String offspringClassName, Boolean _extends); void dataObjectDeleted(String objectClassName); void dataObjectCreated(String objectClassName); void dataObjectSelected(String objectClassName); void dataObjectUnSelected(String objectClassName); Boolean isBaseType(String type); Boolean isPrimitiveType(String type); Boolean isAssignableFrom(String offspringCandidate, String parentCandidate); void setDataModel(DataModel dataModel); void setBaseTypes(List<PropertyType> baseTypes); }
|
@Test public void testIsAssignableFrom() throws Exception { assertFalse(helper.isAssignableFrom(null, null)); assertFalse(helper.isAssignableFrom("", null)); assertFalse(helper.isAssignableFrom(null, "")); assertFalse(helper.isAssignableFrom("", "")); assertFalse(helper.isAssignableFrom("a.A", "a.A")); assertFalse(helper.isAssignableFrom("d.E", "d.E")); assertTrue(helper.isAssignableFrom("a.A", "u.v.W")); assertTrue(helper.isAssignableFrom("a.A", "a.b.c.K")); assertTrue(helper.isAssignableFrom("a.A", "a.b.c.L")); assertTrue(helper.isAssignableFrom("a.b.c.K", "a.A")); assertTrue(helper.isAssignableFrom("a.b.c.L", "a.A")); assertTrue(helper.isAssignableFrom("a.B", "a.A")); assertFalse(helper.isAssignableFrom("a.A", "a.b.F")); assertFalse(helper.isAssignableFrom("a.A", "d.E")); assertTrue(helper.isAssignableFrom("d.D", "a.A")); assertTrue(helper.isAssignableFrom("d.e.H", "a.A")); assertTrue(helper.isAssignableFrom("a.b.F", "k.l.K")); assertTrue(helper.isAssignableFrom("k.l.K", "a.b.F")); helper.dataObjectExtended("a.A", "a.b.F", false); helper.dataObjectExtended("k.l.K", "a.b.F", true); assertFalse(helper.isAssignableFrom("k.l.K", "a.b.F")); assertTrue(helper.isAssignableFrom("a.A", "a.b.F")); helper.dataObjectExtended("a.B", "a.C", false); assertTrue(helper.isAssignableFrom("a.A", "d.E")); assertTrue(helper.isAssignableFrom("a.A", "d.e.H")); assertTrue(helper.isAssignableFrom("d.D", "a.A")); assertTrue(helper.isAssignableFrom("d.e.H", "a.A")); helper.dataObjectExtended("a.B", "a.C", true); helper.dataObjectExtended("k.l.K", "a.b.F", false); helper.dataObjectExtended("a.A", "a.b.F", true); }
|
PersistenceDescriptorXMLMarshaller { public static PersistenceDescriptorModel fromXML( InputStream xmlStream, boolean validate ) throws Exception { DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance(); builderFactory.setNamespaceAware( true ); DocumentBuilder documentBuilder = builderFactory.newDocumentBuilder(); Document document = documentBuilder.parse( xmlStream ); if ( validate ) { Validator validator = getPersistenceSchema().newValidator(); validator.setErrorHandler( new ErrorHandler() { @Override public void warning( SAXParseException e ) throws SAXException { logger.warn( "PersistenceDescriptorModel parsing error: ", e ); } @Override public void error( SAXParseException e ) throws SAXException { logger.error( "PersistenceDescriptorModel parsing error: ", e ); throw e; } @Override public void fatalError( SAXParseException e ) throws SAXException { logger.error( "PersistenceDescriptorModel parsing error: ", e ); throw e; } } ); validator.validate( new DOMSource( document ) ); } DOM2PersistenceDescriptorVisitor visitor = new DOM2PersistenceDescriptorVisitor( document ); return visitor.visit(); } static PersistenceDescriptorModel fromXML( InputStream xmlStream, boolean validate ); static String toXML( PersistenceDescriptorModel persistenceDescriptor ); static void toXML( PersistenceDescriptorModel persistenceDescriptor, OutputStream outputStream ); static final String PERSISTENCE; static final String VERSION; static final String PERSISTENCE_UNIT; static final String NAME; static final String VALUE; static final String TRANSACTION_TYPE; static final String DESCRIPTION; static final String PROVIDER; static final String JTA_DATA_SOURCE; static final String NON_JTA_DATA_SOURCE; static final String MAPPING_FILE; static final String JAR_FILE; static final String CLASS; static final String EXCLUDE_UNLISTED_CLASSES; static final String SHARED_CACHE_MODE; static final String VALIDATION_MODE; static final String PROPERTIES; static final String PROPERTY; }
|
@Test public void readFromXMLTest() { try { PersistenceDescriptorModel descriptor = PersistenceDescriptorXMLMarshaller.fromXML( getInputStream( "persistence.xml" ), false ); assertEqualsDescriptor( expectedDescriptor(), descriptor ); } catch ( Exception e ) { fail( e.getMessage() ); } }
|
PersistableClassValidator { public List<ValidationMessage> validate( String className, ClassLoader classLoader ) { List<ValidationMessage> result = new ArrayList<>( ); Class< ? > clazz; try { if ( className == null || className.trim( ).isEmpty( ) ) { result.add( newErrorMessage( PersistenceDescriptorValidationMessages.PERSISTABLE_CLASS_NAME_EMPTY_ID, PersistenceDescriptorValidationMessages.PERSISTABLE_CLASS_NAME_EMPTY ) ); return result; } clazz = classLoader.loadClass( className ); Annotation[] annotations = clazz.getAnnotations( ); Optional< Annotation > persistable = Arrays.stream( annotations ) .filter( annotation -> Entity.class.equals( annotation.annotationType( ) ) || Embeddable.class.equals( annotation.annotationType( ) ) || MappedSuperclass.class.equals( annotation.annotationType( ) ) ) .findFirst( ); if ( !persistable.isPresent( ) ) { result.add( newErrorMessage( PersistenceDescriptorValidationMessages.CLASS_NOT_PERSISTABLE_ID, MessageFormat.format( PersistenceDescriptorValidationMessages.CLASS_NOT_PERSISTABLE, className ), className ) ); } } catch ( ClassNotFoundException e ) { result.add( newErrorMessage( PersistenceDescriptorValidationMessages.CLASS_NOT_FOUND_ID, MessageFormat.format( PersistenceDescriptorValidationMessages.CLASS_NOT_FOUND, className ), className ) ); } return result; } PersistableClassValidator( ); List<ValidationMessage> validate( String className, ClassLoader classLoader ); }
|
@Test public void testValidateValidPersistableClasses( ) { assertTrue( validator.validate( PersistableClass1.class.getName( ), classLoader ).isEmpty( ) ); assertTrue( validator.validate( PersistableClass2.class.getName( ), classLoader ).isEmpty( ) ); assertTrue( validator.validate( PersistableClass3.class.getName( ), classLoader ).isEmpty( ) ); }
@Test public void testValidateInvalidPersistableClasses( ) { List< ValidationMessage > result = validator.validate( NonPersistableClass1.class.getName( ), classLoader ); assertEquals( 1, result.size( ) ); ValidationMessage expectedMessage = newErrorMessage( PersistenceDescriptorValidationMessages.CLASS_NOT_PERSISTABLE_ID, MessageFormat.format( PersistenceDescriptorValidationMessages.CLASS_NOT_PERSISTABLE, NonPersistableClass1.class.getName( ) ), NonPersistableClass1.class.getName( ) ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( NOT_EXISTING_CLASS, classLoader ); assertEquals( 1, result.size( ) ); expectedMessage = newErrorMessage( PersistenceDescriptorValidationMessages.CLASS_NOT_FOUND_ID, MessageFormat.format( PersistenceDescriptorValidationMessages.CLASS_NOT_FOUND, NOT_EXISTING_CLASS ), NOT_EXISTING_CLASS ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( "", classLoader ); assertEquals( 1, result.size( ) ); expectedMessage = newErrorMessage( PersistenceDescriptorValidationMessages.PERSISTABLE_CLASS_NAME_EMPTY_ID, PersistenceDescriptorValidationMessages.PERSISTABLE_CLASS_NAME_EMPTY ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( null, classLoader ); assertEquals( 1, result.size( ) ); assertEquals( expectedMessage, result.get( 0 ) ); }
|
DataObjectValidationServiceImpl implements DataObjectValidationService { public Collection<ValidationMessage> validateObjectPropertyDeletion(final DataObject dataObject, final ObjectProperty objectProperty) { return objectPropertyDeleteValidators .stream() .flatMap(c -> c.validate(dataObject, objectProperty).stream()) .collect(Collectors.toList()); } DataObjectValidationServiceImpl(); @Inject DataObjectValidationServiceImpl(final Instance<ObjectPropertyDeleteValidator> objectPropertyDeleteValidatorInstance); Collection<ValidationMessage> validateObjectPropertyDeletion(final DataObject dataObject,
final ObjectProperty objectProperty); }
|
@Test public void validateObjectPropertyDeletion() { Collection<ValidationMessage> result = validationService.validateObjectPropertyDeletion(new DataObjectImpl(), new ObjectPropertyImpl()); assertEquals(2, result.size()); assertTrue(result.contains(message1)); assertTrue(result.contains(message2)); }
|
PropertyValidator { public List<ValidationMessage> validate( String name, String value ) { return validate( name, value, -1 ); } PropertyValidator(); List<ValidationMessage> validate( String name, String value ); List<ValidationMessage> validate( String name, String value, int propertyIndex ); }
|
@Test public void testValidateValidProperties( ) { List< ValidationMessage > result = validator.validate( PROPERTY_NAME, "value" ); assertTrue( result.isEmpty( ) ); result = validator.validate( PROPERTY_NAME, "value", 0 ); assertTrue( result.isEmpty( ) ); }
@Test public void testValidateInvalidProperties( ) { List< ValidationMessage > result = validator.validate( "", "value" ); assertEquals( 1, result.size( ) ); ValidationMessage expectedMessage = newErrorMessage( PersistenceDescriptorValidationMessages.PROPERTY_NAME_EMPTY_ID, PersistenceDescriptorValidationMessages.PROPERTY_NAME_EMPTY ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( null, "value" ); assertEquals( 1, result.size( ) ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( "", "value", 1 ); assertEquals( 1, result.size( ) ); expectedMessage = newErrorMessage( PersistenceDescriptorValidationMessages.INDEXED_PROPERTY_NAME_EMPTY_ID, MessageFormat.format( PersistenceDescriptorValidationMessages.INDEXED_PROPERTY_NAME_EMPTY, Integer.toString( 1 ) ), Integer.toString( 1 ) ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( null, "value", 1 ); assertEquals( 1, result.size( ) ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( PROPERTY_NAME, "" ); assertEquals( 1, result.size( ) ); expectedMessage = newWarningMessage( PersistenceDescriptorValidationMessages.PROPERTY_VALUE_EMPTY_ID, MessageFormat.format( PersistenceDescriptorValidationMessages.PROPERTY_VALUE_EMPTY, PROPERTY_NAME ), PROPERTY_NAME ); assertEquals( expectedMessage, result.get( 0 ) ); result = validator.validate( PROPERTY_NAME, null ); assertEquals( 1, result.size( ) ); assertEquals( expectedMessage, result.get( 0 ) ); }
|
DataModelerEventObserver { public void onDataObjectCreated(@Observes DataObjectCreatedEvent event) { Path descriptorPath; PersistenceDescriptorModel persistenceDescriptor; if (isPersistable(event.getCurrentDataObject())) { descriptorPath = descriptorService.calculatePersistenceDescriptorPath(event.getCurrentModule()); persistenceDescriptor = safeLoad(descriptorPath); if (persistenceDescriptor != null && !containsClass(persistenceDescriptor.getPersistenceUnit(), event.getCurrentDataObject().getClassName())) { persistenceDescriptor.getPersistenceUnit().getClasses().add(new PersistableDataObject(event.getCurrentDataObject().getClassName())); descriptorService.save(descriptorPath, persistenceDescriptor, null, "Entity added to persistence descriptor"); } } } DataModelerEventObserver(); @Inject DataModelerEventObserver(final PersistenceDescriptorService descriptorService,
final @Named("ioStrategy") IOService ioService); void onDataObjectCreated(@Observes DataObjectCreatedEvent event); void onDataObjectDeleted(@Observes DataObjectDeletedEvent event); }
|
@Test public void onPersistableDataObjectCreatedTest() { DataObjectCreatedEvent createdEvent = new DataObjectCreatedEvent(module, dataObject); eventObserver.onDataObjectCreated(createdEvent); verify(descriptorService, times(1)).save(eq(descriptorPath), eq(descriptorModel), any(Metadata.class), anyString()); assertTrue(descriptorModel.getPersistenceUnit().getClasses().contains(new PersistableDataObject(dataObject.getClassName()))); }
@Test public void onNonPersistableDataObjectCreatedTest() { descriptorModel.getPersistenceUnit().getClasses().add(new PersistableDataObject("package1.PersistableObject")); DataObjectCreatedEvent createdEvent = new DataObjectCreatedEvent(module, dataObject); eventObserver.onDataObjectCreated(createdEvent); verify(descriptorService, times(0)).save(eq(descriptorPath), eq(descriptorModel), any(Metadata.class), anyString()); assertEquals(1, descriptorModel.getPersistenceUnit().getClasses().size()); }
@Test public void onNonPersistableDataObjectDeletedTest() { DataObject dataObject = new DataObjectImpl("package1", "NonPersistableObject"); DataObjectCreatedEvent createdEvent = new DataObjectCreatedEvent(module, dataObject); eventObserver.onDataObjectCreated(createdEvent); descriptorModel.getPersistenceUnit().getClasses().add(new PersistableDataObject(createdEvent.getCurrentDataObject().getClassName())); verify(descriptorService, times(0)).save(eq(descriptorPath), eq(descriptorModel), any(Metadata.class), anyString()); assertEquals(1, descriptorModel.getPersistenceUnit().getClasses().size()); }
|
DataModelerEventObserver { public void onDataObjectDeleted(@Observes DataObjectDeletedEvent event) { Path descriptorPath; PersistenceDescriptorModel persistenceDescriptor; descriptorPath = descriptorService.calculatePersistenceDescriptorPath(event.getCurrentModule()); persistenceDescriptor = safeLoad(descriptorPath); if (persistenceDescriptor != null && containsClass(persistenceDescriptor.getPersistenceUnit(), event.getCurrentDataObject().getClassName())) { persistenceDescriptor.getPersistenceUnit().getClasses().remove(new PersistableDataObject(event.getCurrentDataObject().getClassName())); descriptorService.save(descriptorPath, persistenceDescriptor, null, "Entity removed from persistence descriptor"); } } DataModelerEventObserver(); @Inject DataModelerEventObserver(final PersistenceDescriptorService descriptorService,
final @Named("ioStrategy") IOService ioService); void onDataObjectCreated(@Observes DataObjectCreatedEvent event); void onDataObjectDeleted(@Observes DataObjectDeletedEvent event); }
|
@Test public void onPersistableDataObjectDeletedTest() { DataObjectDeletedEvent deletedEvent = new DataObjectDeletedEvent(module, dataObject); descriptorModel.getPersistenceUnit().getClasses().add(new PersistableDataObject(deletedEvent.getCurrentDataObject().getClassName())); eventObserver.onDataObjectDeleted(deletedEvent); verify(descriptorService, times(1)).save(eq(descriptorPath), eq(descriptorModel), any(Metadata.class), anyString()); assertFalse(descriptorModel.getPersistenceUnit().getClasses().contains(new PersistableDataObject(dataObject.getClassName()))); }
|
DataModelerServiceHelper { public List<DataModelerError> toDataModelerError(List<DriverError> errors) { final List<DataModelerError> result = new ArrayList<>(); if (errors == null) { return result; } for (DriverError error : errors) { DataModelerError dataModelerError = new DataModelerError( error.getId(), error.getMessage(), Level.ERROR, error.getFile(), error.getLine(), error.getColumn()); result.add(dataModelerError); } return result; } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@Test public void testToDataModelerErrorFromDriverError() { ArrayList<DriverError> driverErrors = new ArrayList<>(); for(int i = 0; i < 10; i++) { driverErrors.add(new DriverError(i, "message"+i, mock(Path.class), i, i)); } List<DataModelerError> result = serviceHelper.toDataModelerError(driverErrors); assertEquals(driverErrors.size(), result.size()); for (int i = 0; i < driverErrors.size(); i++) { assertErrorEquals(driverErrors.get(i), result.get(i)); } }
@Test public void testToDataModelerErrorFromSyntaxError() { ArrayList<SyntaxError> syntaxErrors = new ArrayList<>(); SyntaxError syntaxError; org.uberfire.java.nio.file.Path path = testRootPath.resolve(JAVA_FILE_FOR_ERRORS_TEST); for(int i = 0; i < 10; i++) { syntaxError = mock(SyntaxError.class); when(syntaxError.getDescription()).thenReturn("message"+i); if (i % 2 == 0) { when(syntaxError.isError()).thenReturn(true); } else { when(syntaxError.isError()).thenReturn(false); } when(syntaxError.getLine()).thenReturn(i); when(syntaxError.getColumn()).thenReturn(i); syntaxErrors.add(syntaxError); } List<DataModelerError> result = serviceHelper.toDataModelerError(syntaxErrors, path); assertEquals(syntaxErrors.size(), result.size()); for (int i = 0; i < syntaxErrors.size(); i++) { assertErrorEquals(syntaxErrors.get(i), result.get(i), Paths.convert(path)); } }
|
DataModelerServiceHelper { public List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors) { final List<ValidationMessage> validationMessages = new ArrayList<>(); ValidationMessage validationMessage; if (errors == null) { return validationMessages; } for (DataModelerError error : errors) { validationMessage = new ValidationMessage(); validationMessage.setPath(error.getFile()); validationMessage.setText(error.getMessage()); validationMessage.setColumn(error.getColumn()); validationMessage.setLine(error.getLine()); validationMessage.setId(error.getId()); if (error.getLevel() != null) { validationMessage.setLevel(error.getLevel()); } validationMessages.add(validationMessage); } return validationMessages; } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@Test public void testToValidationMessageFromDataModelerError() { ArrayList<DataModelerError> dataModelerErrors = new ArrayList<>(); DataModelerError dataModelerError; Level level; for(int i = 0; i < 10; i++) { level = Level.values()[i % 3]; dataModelerError = new DataModelerError(i, "message"+i,level, mock(Path.class), i, i); dataModelerErrors.add(dataModelerError); } List<ValidationMessage> result = serviceHelper.toValidationMessage(dataModelerErrors); assertEquals(dataModelerErrors.size(), result.size()); for (int i = 0; i < dataModelerErrors.size(); i++) { assertErrorEquals(dataModelerErrors.get(i), result.get(i)); } }
|
DataModelerServiceHelper { public String calculateClassName(final Module module, final org.uberfire.backend.vfs.Path path) { PortablePreconditions.checkNotNull("module", module); if (path == null) { return null; } final Package defaultPackage = moduleService.resolveDefaultPackage(module); if (defaultPackage == null) { return null; } final Path mainSrcNioPath = Paths.convert(defaultPackage.getPackageMainSrcPath()); final Path testSrcNioPath = Paths.convert(defaultPackage.getPackageTestSrcPath()); final Path nioPath = Paths.convert(path); Path relativePath = null; if (mainSrcNioPath != null && nioPath.startsWith(mainSrcNioPath)) { relativePath = mainSrcNioPath.relativize(nioPath); } else if (testSrcNioPath != null && nioPath.startsWith(testSrcNioPath)) { relativePath = testSrcNioPath.relativize(nioPath); } if (relativePath != null) { String className = relativePath.toString().replace("/", "."); return className.substring(0, className.lastIndexOf(".java")); } return null; } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@Test public void testCalculateClassName() { Module module = mock(Module.class); Package defaultPackage = mock(Package.class); Path javaFile1Main = Paths.convert(testRootPath.resolve(JAVA_FILE_1_MAIN_PATH)); Path javaFile1Test = Paths.convert(testRootPath.resolve(JAVA_FILE_1_TEST_PATH)); Path javaFile2Main = Paths.convert(testRootPath.resolve(JAVA_FILE_2_MAIN_PATH)); Path javaFile2Test = Paths.convert(testRootPath.resolve(JAVA_FILE_2_TEST_PATH)); Path javaFile3Main = Paths.convert(testRootPath.resolve(JAVA_FILE_3_MAIN_PATH)); Path javaFile3Test = Paths.convert(testRootPath.resolve(JAVA_FILE_3_TEST_PATH)); Path javaFileInOtherModule = Paths.convert(testRootPath.resolve(JAVA_FILE_IN_OTHER_MODULE)); assertNull(serviceHelper.calculateClassName(module, null)); assertNull(serviceHelper.calculateClassName(module, javaFile1Main)); assertNull(serviceHelper.calculateClassName(module, javaFile1Test)); assertNull(serviceHelper.calculateClassName(module, javaFile2Main)); assertNull(serviceHelper.calculateClassName(module, javaFile2Test)); assertNull(serviceHelper.calculateClassName(module, javaFile3Main)); assertNull(serviceHelper.calculateClassName(module, javaFile3Test)); assertNull(serviceHelper.calculateClassName(module, javaFileInOtherModule)); when(moduleService.resolveDefaultPackage(module)).thenReturn(defaultPackage); Path mainSrcPath = Paths.convert(testRootPath.resolve("myProject/src/main/java")); Path testSrcPath = Paths.convert(testRootPath.resolve("myProject/src/test/java")); when(defaultPackage.getPackageMainSrcPath()).thenReturn(mainSrcPath); when(defaultPackage.getPackageTestSrcPath()).thenReturn(testSrcPath); assertNull(serviceHelper.calculateClassName(module, null)); assertEquals(JAVA_FILE_1_CLASS, serviceHelper.calculateClassName(module, javaFile1Main)); assertEquals(JAVA_FILE_1_CLASS, serviceHelper.calculateClassName(module, javaFile1Test)); assertEquals(JAVA_FILE_2_CLASS, serviceHelper.calculateClassName(module, javaFile2Main)); assertEquals(JAVA_FILE_2_CLASS, serviceHelper.calculateClassName(module, javaFile2Test)); assertEquals(JAVA_FILE_3_CLASS, serviceHelper.calculateClassName(module, javaFile3Main)); assertEquals(JAVA_FILE_3_CLASS, serviceHelper.calculateClassName(module, javaFile3Test)); assertNull(serviceHelper.calculateClassName(module, javaFileInOtherModule)); }
|
DataModelerServiceHelper { public CommentedOption makeCommentedOption(final String commitMessage) { return commentedOptionFactory.makeCommentedOption(commitMessage); } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@Test public void testMakeCommentedOption() { String message = "message"; CommentedOption commentedOption = mock(CommentedOption.class); when(commentedOptionFactory.makeCommentedOption(message)).thenReturn(commentedOption); assertEquals(commentedOption, serviceHelper.makeCommentedOption(message)); }
|
DataModelerServiceHelper { public Package ensurePackageStructure(final Module module, final String packageName) { if (packageName == null || "".equals(packageName) || module == null) { return null; } final Package defaultPackage = moduleService.resolveDefaultPackage(module); final Path defaultPackagePath = Paths.convert(defaultPackage.getPackageMainSrcPath()); final String newPackageName = packageName.replace(".", "/"); final Path newPackagePath = defaultPackagePath.resolve(newPackageName); if (!ioService.exists(newPackagePath)) { return moduleService.newPackage(defaultPackage, packageName); } else { return moduleService.resolvePackage(Paths.convert(newPackagePath)); } } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@Test public void testEnsurePackageStructureWhenNoValuesProvided() { prepareEnsurePackageTest(); assertNull(serviceHelper.ensurePackageStructure(module, null)); assertNull(serviceHelper.ensurePackageStructure(module, "")); }
@Test public void testEnsurePackageStructureWhenProvidedPackageAlreadyExists() { prepareEnsurePackageTest(); Package existingPackage = mock(Package.class); when(ioService.exists(any(org.uberfire.java.nio.file.Path.class))).thenReturn(true); when(moduleService.resolvePackage(any(Path.class))).thenReturn(existingPackage); Package result = serviceHelper.ensurePackageStructure(module, NEW_PACKAGE_NAME); assertEquals(existingPackage, result); verify(moduleService, never()).newPackage(any(Package.class), anyString()); }
@Test public void testEnsurePackageStructureWhenProvidedPackageDoNotExists() { prepareEnsurePackageTest(); Package createdPackage = mock(Package.class); when(ioService.exists(any(org.uberfire.java.nio.file.Path.class))).thenReturn(false); when(moduleService.newPackage(defaultPackage, NEW_PACKAGE_NAME)).thenReturn(createdPackage); Package result = serviceHelper.ensurePackageStructure(module, NEW_PACKAGE_NAME); assertEquals(createdPackage, result); verify(moduleService).newPackage(defaultPackage, NEW_PACKAGE_NAME); }
|
DataModelerServiceHelper { public Set<String> resolvePackages(final Module project) { final Set<Package> packages = moduleService.resolvePackages(project); return packages.stream() .map(Package::getPackageName) .collect(Collectors.toSet()); } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@SuppressWarnings("unchecked") @Test public void testResolvePackages() { Module module = mock(Module.class); Set<Package> packages = new HashSet(); Package pkg; for (int i = 0; i < 10; i++) { pkg = mock(Package.class); when(pkg.getPackageName()).thenReturn("package"+i); packages.add(pkg); } when(moduleService.resolvePackages(module)).thenReturn(packages); Set<String> result = serviceHelper.resolvePackages(module); assertEquals(packages.size(), result.size()); packages.forEach(existingPkg -> assertTrue(result.contains(existingPkg.getPackageName()))); }
|
DataModelerServiceHelper { public Path calculateFilePath(final String className, final Path javaPath) { PortablePreconditions.checkNotNull("className", className); PortablePreconditions.checkNotNull("javaPath", javaPath); String pathUri = className; if (className.contains(".")) { pathUri = className.replace(".", "/"); } return javaPath.resolve(pathUri + ".java"); } DataModelerServiceHelper(); @Inject DataModelerServiceHelper(final KieModuleService moduleService,
final @Named("ioStrategy") IOService ioService,
final CommentedOptionFactory commentedOptionFactory); List<DataModelerError> toDataModelerError(List<DriverError> errors); List<DataModelerError> toDataModelerError(final List<SyntaxError> syntaxErrors,
final Path file); List<ValidationMessage> toValidationMessage(final List<DataModelerError> errors); CommentedOption makeCommentedOption(final String commitMessage); Package ensurePackageStructure(final Module module,
final String packageName); Set<String> resolvePackages(final Module project); String calculateClassName(final Module module,
final org.uberfire.backend.vfs.Path path); Path calculateFilePath(final String className,
final Path javaPath); }
|
@Test public void testCalculateFilePath() { org.uberfire.java.nio.file.Path javaPath = testRootPath; String className = "PojoWithNoPackage背景色"; String expectedFile = testRootPath.toString() + "/PojoWithNoPackage背景色.java"; org.uberfire.java.nio.file.Path result = serviceHelper.calculateFilePath(className, javaPath); assertEquals(expectedFile, result.toString()); className = "com.myspace.PojoWithPackage背景色"; expectedFile = testRootPath.toString() + "/com/myspace/PojoWithPackage背景色.java"; result = serviceHelper.calculateFilePath(className, javaPath); assertEquals(expectedFile, result.toString()); }
|
JavaFileIndexer extends AbstractFileIndexer { @Override public IndexBuilder fillIndexBuilder(final Path path) throws Exception { if (!ioService.exists(path)) { logger.error("Unable to index {} : file does not exist.", path.toUri()); return null; } final KieModule module = getModule(path); if (module == null) { logger.error("Unable to index " + path.toUri().toString() + ": module could not be resolved."); return null; } final Package pkg = getPackage(path); if (pkg == null) { logger.error("Unable to index " + path.toUri().toString() + ": package could not be resolved."); return null; } final DefaultIndexBuilder builder = new DefaultIndexBuilder(Paths.convert(path).getFileName(), module, pkg); final String javaSource = ioService.readAllString(path); org.jboss.forge.roaster.model.JavaType<?> javaType = Roaster.parse(javaSource); if (javaType.getSyntaxErrors() == null || javaType.getSyntaxErrors().isEmpty()) { if (javaFileIndexerExtensions != null) { for (JavaFileIndexerExtension javaFileIndexerExtension : javaFileIndexerExtensions) { javaFileIndexerExtension.process(builder, javaType); } } String pkgName = pkg.getPackageName(); pkgName = javaType.getPackage(); if (pkgName == null) { pkgName = ""; } builder.setPackageName(pkgName); String javaTypeName = javaType.getQualifiedName(); Resource resParts = new Resource(javaTypeName, ResourceType.JAVA); if (javaType instanceof JavaSource) { ClassLoader moduleClassLoader = getModuleClassLoader(module); JavaSourceVisitor visitor = new JavaSourceVisitor((JavaSource) javaType, moduleClassLoader, resParts); visitor.visit((JavaSource) javaType); addReferencedResourcesToIndexBuilder(builder, visitor); } builder.addGenerator(resParts); } return builder; } @Override boolean supportsPath(final Path path); @Override IndexBuilder fillIndexBuilder(final Path path); }
|
@Test public void testFillIndexBuilderWithUnavailablePath() throws Exception { final Path mockPath = mock(Path.class); when(ioService.exists(mockPath)).thenReturn(false); assertNull(indexer.fillIndexBuilder(mockPath)); }
|
JavaSourceVisitor extends ResourceReferenceCollector { public void visit(JavaSource javaSource) { List<Import> imports = javaSource.getImports(); for (Import javaImport : imports) { visit(javaImport); } if (javaSource instanceof Body) { visit((Body) javaSource); } else if (javaSource instanceof JavaAnnotationSource) { visit((JavaAnnotationSource) javaSource); } else if (javaSource instanceof JavaClassSource) { visit((JavaClassSource) javaSource); } else if (javaSource instanceof JavaEnumSource) { visit((JavaEnumSource) javaSource); } else if (javaSource instanceof JavaInterfaceSource) { visit((JavaInterfaceSource) javaSource); } } JavaSourceVisitor(JavaSource javaSource, ClassLoader classLoader, Resource resParts); void visit(JavaSource javaSource); void visit(AnnotationSource<? extends JavaClassSource> annoSource); void visit(Body body); void visit(FieldSource<? extends JavaSource> fieldSource); void visit(JavaAnnotationSource javaAnnoSource); void visit(JavaClassSource javaClassSource); void visit(JavaEnumSource javaEnumSource); void visit(Import javaImport); void visit(JavaInterfaceSource interfaceSource); void visit(MethodSource<? extends JavaClassSource> methodSource); void addJavaResourceReference(String fullyQualifiedName); }
|
@Test public void visitAnnotationSources() { for ( AnnotationSource annotationSource : javaClassSource.getAnnotations() ) { visitor.visit( annotationSource ); } checkVisitor( Arrays.asList( "ref:java => org.kie.workbench.common.screens.datamodeller.backend.server.indexing.Annotation1" ) ); }
@Test public void visitImports() { for ( Import importSource : javaClassSource.getImports() ) { visitor.visit( importSource ); } checkVisitor( Arrays.asList( "ref:java => java.math.BigDecimal", "ref:java => java.io.Serializable" ) ); }
@Test public void visitFields() { for ( FieldSource fieldSource : javaClassSource.getFields() ) { visitor.visit( fieldSource ); } checkVisitor( Arrays.asList( "ref:java => int", "ref:java => java.math.BigDecimal" ) ); }
@Test public void visitMethods() { for ( MethodSource methodSource : javaClassSource.getMethods() ) { visitor.visit( methodSource ); } checkVisitor( Arrays.asList( "ref:java => int", "ref:java => java.math.BigDecimal", "ref:java => org.kie.workbench.common.screens.datamodeller.backend.server.indexing.Pojo1" ) ); }
@Test public void visitInterface() { visitor.visit( javaInterfaceSource ); checkVisitor( Arrays.asList( "ref:java => int", "ref:java => java.lang.String", "ref:java => org.kie.workbench.common.screens.datamodeller.backend.server.indexing.Annotation1" ) ); }
@Test public void visitEnum() { visitor.visit( javaEnumSource ); checkVisitor( Arrays.asList( "ref:java => int" ) ); }
@Test public void visitJavaClassImplmentingInterfaceWithGenerics() { visitor.visit(javaClassSource2); checkVisitor(Arrays.asList("ref:java => org.kie.workbench.common.screens.datamodeller.backend.server.indexing.Pojo3", "ref:java => java.lang.Object", "ref:java => java.lang.Comparable", "ref:java => int")); }
|
PersistenceDescriptorEditorServiceImpl extends KieService<PersistenceDescriptorEditorContent> implements PersistenceDescriptorEditorService { @Override public Path saveAndRename(final Path path, final String newFileName, final Metadata metadata, final PersistenceDescriptorEditorContent content, final String comment) { return saveAndRenameService.saveAndRename(path, newFileName, metadata, content, comment); } @Inject PersistenceDescriptorEditorServiceImpl(final @Named("ioStrategy") IOService ioService,
final PersistenceDescriptorService descriptorService,
final RenameService renameService,
final SaveAndRenameServiceImpl<PersistenceDescriptorEditorContent, Metadata> saveAndRenameService); @PostConstruct void init(); @Override PersistenceDescriptorEditorContent loadContent(Path path, boolean createIfNotExists); @Override Path save(Path path, PersistenceDescriptorEditorContent content, Metadata metadata, String comment); Pair<Path, Boolean> createIfNotExists(Path path); @Override Path saveAndRename(final Path path,
final String newFileName,
final Metadata metadata,
final PersistenceDescriptorEditorContent content,
final String comment); @Override Path rename(final Path path,
final String newName,
final String comment); }
|
@Test public void testSaveAndRename() throws Exception { final Path path = mock(Path.class); final Path expectedPath = mock(Path.class); final Metadata metadata = mock(Metadata.class); final PersistenceDescriptorEditorContent content = mock(PersistenceDescriptorEditorContent.class); final String newName = "newName"; final String comment = "comment"; doReturn(expectedPath).when(saveAndRenameService).saveAndRename(path, newName, metadata, content, comment); final Path actualPath = service.saveAndRename(path, newName, metadata, content, comment); verify(saveAndRenameService).saveAndRename(path, newName, metadata, content, comment); assertEquals(expectedPath, actualPath); }
|
PersistenceDescriptorEditorServiceImpl extends KieService<PersistenceDescriptorEditorContent> implements PersistenceDescriptorEditorService { @Override public Path rename(final Path path, final String newName, final String comment) { return renameService.rename(path, newName, comment); } @Inject PersistenceDescriptorEditorServiceImpl(final @Named("ioStrategy") IOService ioService,
final PersistenceDescriptorService descriptorService,
final RenameService renameService,
final SaveAndRenameServiceImpl<PersistenceDescriptorEditorContent, Metadata> saveAndRenameService); @PostConstruct void init(); @Override PersistenceDescriptorEditorContent loadContent(Path path, boolean createIfNotExists); @Override Path save(Path path, PersistenceDescriptorEditorContent content, Metadata metadata, String comment); Pair<Path, Boolean> createIfNotExists(Path path); @Override Path saveAndRename(final Path path,
final String newFileName,
final Metadata metadata,
final PersistenceDescriptorEditorContent content,
final String comment); @Override Path rename(final Path path,
final String newName,
final String comment); }
|
@Test public void testRename() throws Exception { final Path path = mock(Path.class); final Path expectedPath = mock(Path.class); final String newName = "newName"; final String comment = "comment"; doReturn(expectedPath).when(renameService).rename(path, newName, comment); final Path actualPath = service.rename(path, newName, comment); verify(renameService).rename(path, newName, comment); assertEquals(expectedPath, actualPath); }
|
ProjectImportsScreenPresenter extends KieEditor<ProjectImports> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; this.fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(versionRecordManager.getCurrentPath(), getRenameValidator()) .addRename(getSaveAndRename()) .addDelete(versionRecordManager.getPathToLatest(), getRenameValidator()); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } ProjectImportsScreenPresenter(); @Inject ProjectImportsScreenPresenter(final ProjectImportsScreenView view,
final Caller<ProjectImportsService> importsService,
final Others category); @OnStartup void init(final ObservablePath path,
final PlaceRequest place); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartView IsWidget asWidget(); @OnClose @Override void onClose(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnMayClose boolean mayClose(); static final String EDITOR_ID; }
|
@Test public void testMakeMenuBar() { doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); presenter.makeMenuBar(); verify(menuBuilder).addSave(any(MenuItem.class)); verify(menuBuilder).addCopy(any(Path.class), any(AssetUpdateValidator.class)); verify(menuBuilder).addRename(any(Command.class)); verify(menuBuilder).addDelete(any(Path.class), any(AssetUpdateValidator.class)); verify(menuBuilder).addNewTopLevelMenu(alertsButtonMenuItem); verify(presenter).addDownloadMenuItem(menuBuilder); }
@Test public void testMakeMenuBarWithoutUpdateProjectPermission() { doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(false)).when(projectController).canUpdateProject(any()); presenter.makeMenuBar(); verify(menuBuilder, never()).addSave(any(MenuItem.class)); verify(menuBuilder, never()).addCopy(any(Path.class), any(AssetUpdateValidator.class)); verify(menuBuilder, never()).addRename(any(Command.class)); verify(menuBuilder, never()).addDelete(any(Path.class), any(AssetUpdateValidator.class)); verify(menuBuilder).addNewTopLevelMenu(alertsButtonMenuItem); }
|
ProjectImportsScreenPresenter extends KieEditor<ProjectImports> { @Override protected Supplier<ProjectImports> getContentSupplier() { return () -> model; } ProjectImportsScreenPresenter(); @Inject ProjectImportsScreenPresenter(final ProjectImportsScreenView view,
final Caller<ProjectImportsService> importsService,
final Others category); @OnStartup void init(final ObservablePath path,
final PlaceRequest place); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartView IsWidget asWidget(); @OnClose @Override void onClose(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnMayClose boolean mayClose(); static final String EDITOR_ID; }
|
@Test public void testGetContentSupplier() { final ProjectImports content = mock(ProjectImports.class); presenter.setModel(content); final Supplier<ProjectImports> contentSupplier = presenter.getContentSupplier(); assertEquals(content, contentSupplier.get()); }
|
ProjectImportsScreenPresenter extends KieEditor<ProjectImports> { @Override protected Caller<? extends SupportsSaveAndRename<ProjectImports, Metadata>> getSaveAndRenameServiceCaller() { return importsService; } ProjectImportsScreenPresenter(); @Inject ProjectImportsScreenPresenter(final ProjectImportsScreenView view,
final Caller<ProjectImportsService> importsService,
final Others category); @OnStartup void init(final ObservablePath path,
final PlaceRequest place); @WorkbenchPartTitle String getTitleText(); @WorkbenchPartView IsWidget asWidget(); @OnClose @Override void onClose(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @OnMayClose boolean mayClose(); static final String EDITOR_ID; }
|
@Test public void testGetSaveAndRenameServiceCaller() { final Caller<? extends SupportsSaveAndRename<ProjectImports, Metadata>> serviceCaller = presenter.getSaveAndRenameServiceCaller(); assertEquals(this.serviceCaller, serviceCaller); }
|
HomePresenter { public void setup() { profilePreferences.load(loadedProfilePreferences -> { modelProvider.initialize(()->{ final HomeModel model = modelProvider.get(loadedProfilePreferences); view.setWelcome(model.getWelcome()); view.setDescription(model.getDescription()); view.setBackgroundImageUrl(model.getBackgroundImageUrl()); model.getShortcuts().forEach(shortcut -> { final ShortcutPresenter shortcutPresenter = shortcutPresenters.get(); shortcutPresenter.setup(shortcut); view.addShortcut(shortcutPresenter); }); }); }, RuntimeException::new); } @Inject HomePresenter(final View view,
final TranslationService translationService,
final HomeModelProvider modelProvider,
final ManagedInstance<ShortcutPresenter> shortcutPresenters,
final ProfilePreferences profilePreferences); void setup(); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView UberElement<HomePresenter> getView(); }
|
@Test public void setupTest() { presenter.setup(); verify(view).setWelcome("welcome"); verify(view).setDescription("description"); verify(view).setBackgroundImageUrl("backgroundImageUrl"); verify(view, times(3)).addShortcut(any()); }
|
ShortcutPresenter { public void setup(final HomeShortcut shortcut) { setupIcon(shortcut); view.setHeading(shortcut.getHeading()); setupAction(shortcut); setupSubHeading(shortcut); } @Inject ShortcutPresenter(final View view,
final ShortcutHelper shortcutHelper,
final ManagedInstance<ShortcutSubHeadingLinkPresenter> linkPresenters,
final ManagedInstance<ShortcutSubHeadingTextPresenter> textPresenters); @PostConstruct void init(); void setup(final HomeShortcut shortcut); View getView(); }
|
@Test public void setupTest() { final HomeShortcut shortcut = ModelUtils.makeShortcut("iconCss iconCss2", "heading", "subHeadingPrefix{0}subHeadingSuffix", mock(Command.class)); final HomeShortcutLink link = new HomeShortcutLink("label", "perspectiveIdentifier"); shortcut.addLink(link); presenter.setup(shortcut); verify(view).addIconClass("iconCss"); verify(view).addIconClass("iconCss2"); verify(view).setHeading(shortcut.getHeading()); verify(view).setAction(shortcut.getOnClickCommand()); verify(textPresenter).setup(shortcut.getSubHeading(), 1); verify(textPresenter).setup(shortcut.getSubHeading(), 2); verify(view, times(2)).addSubHeadingChild(textPresenter.getView()); verify(linkPresenter).setup(link); verify(view).addSubHeadingChild(linkPresenter.getView()); }
@Test public void setupWithNoActionPermissionTest() { doReturn(false).when(shortcutHelper).authorize(any(HomeShortcut.class)); final HomeShortcut shortcut = ModelUtils.makeShortcut("iconCss", "heading", "subHeadingPrefix", mock(Command.class)); presenter.setup(shortcut); verify(view, never()).setAction(shortcut.getOnClickCommand()); }
|
ShortcutSubHeadingLinkPresenter { public void setup(final HomeShortcutLink link) { this.link = link; view.setLabel(link.getLabel()); if (!shortcutHelper.authorize(link.getPerspectiveIdentifier())) { view.disable(); } } @Inject ShortcutSubHeadingLinkPresenter(final View view,
final ShortcutHelper shortcutHelper); @PostConstruct void init(); void setup(final HomeShortcutLink link); View getView(); }
|
@Test public void setupWithPermissionTest() { doReturn(true).when(shortcutHelper).authorize("perspectiveIdentifier"); presenter.setup(new HomeShortcutLink("label", "perspectiveIdentifier")); verify(view).setLabel("label"); verify(view, never()).disable(); }
@Test public void setupWithoutPermissionTest() { doReturn(false).when(shortcutHelper).authorize("perspectiveIdentifier"); presenter.setup(new HomeShortcutLink("label", "perspectiveIdentifier")); verify(view).setLabel("label"); verify(view).disable(); }
|
ShortcutSubHeadingLinkPresenter { void goToPerspective() { shortcutHelper.goTo(link.getPerspectiveIdentifier()); } @Inject ShortcutSubHeadingLinkPresenter(final View view,
final ShortcutHelper shortcutHelper); @PostConstruct void init(); void setup(final HomeShortcutLink link); View getView(); }
|
@Test public void goToPerspectiveTest() { presenter.setup(new HomeShortcutLink("label", "perspectiveIdentifier")); presenter.goToPerspective(); verify(shortcutHelper).goTo("perspectiveIdentifier"); }
|
ShortcutSubHeadingTextPresenter { public void setup(final String text, final int part) { view.setText(shortcutHelper.getPart(text, part)); } @Inject ShortcutSubHeadingTextPresenter(final View view,
final ShortcutHelper shortcutHelper); @PostConstruct void init(); void setup(final String text,
final int part); View getView(); }
|
@Test public void setupTest() { doReturn("parsedText").when(shortcutHelper).getPart(anyString(), anyInt()); presenter.setup("text", 1); verify(view).setText("parsedText"); }
|
ShortcutHelper { public String getPart(final String text, final int part) { if (part < 1) { throw new RuntimeException("The first part is the number one."); } int beginIndex = 0; if (part > 1) { final int i = part - 2; final String s = "{" + i + "}"; beginIndex = text.indexOf(s); if (beginIndex < 0) { throw new RuntimeException("The translation " + text + " is missing parameters."); } else { beginIndex += String.valueOf(i).length() + 2; } } final int i2 = part - 1; final String s2 = "{" + i2 + "}"; int endIndex = text.indexOf(s2); if (endIndex < 0) { endIndex = text.length(); } return text.substring(beginIndex, endIndex); } ShortcutHelper(); @Inject ShortcutHelper(final AuthorizationManager authorizationManager,
final User user,
final PlaceManager placeManager); String getPart(final String text,
final int part); void goTo(final String perspectiveIdentifier); boolean authorize(final String perspective); boolean authorize(final HomeShortcut shortcut); }
|
@Test(expected = RuntimeException.class) public void partLessThanOneTest() { shortcutHelper.getPart("text", 0); }
@Test(expected = RuntimeException.class) public void nonexistentSecondPartTest() { shortcutHelper.getPart("text", 2); }
@Test(expected = RuntimeException.class) public void nonexistentThirdPartTest() { shortcutHelper.getPart("text{0}more-text", 3); }
@Test public void onlyOnePartTest() { final String text = "first-part"; final String firstPart = shortcutHelper.getPart(text, 1); assertEquals("first-part", firstPart); }
@Test public void threeValidPartsTest() { final String text = "first-part{0}second-part{1}third-part"; final String firstPart = shortcutHelper.getPart(text, 1); assertEquals("first-part", firstPart); final String secondPart = shortcutHelper.getPart(text, 2); assertEquals("second-part", secondPart); final String thirdPart = shortcutHelper.getPart(text, 3); assertEquals("third-part", thirdPart); }
|
ShortcutHelper { public boolean authorize(final String perspective) { return authorizationManager.authorize(new ResourceRef(perspective, PERSPECTIVE), user); } ShortcutHelper(); @Inject ShortcutHelper(final AuthorizationManager authorizationManager,
final User user,
final PlaceManager placeManager); String getPart(final String text,
final int part); void goTo(final String perspectiveIdentifier); boolean authorize(final String perspective); boolean authorize(final HomeShortcut shortcut); }
|
@Test public void testAuthorizePositive() throws Exception { final String perspectiveId = "perspectiveId"; final ArgumentCaptor<ResourceRef> resourceRefArgumentCaptor = ArgumentCaptor.forClass(ResourceRef.class); doReturn(true).when(authorizationManager).authorize(any(ResourceRef.class), eq(user)); assertTrue(shortcutHelper.authorize(perspectiveId)); verify(authorizationManager).authorize(resourceRefArgumentCaptor.capture(), eq(user)); assertEquals(perspectiveId, resourceRefArgumentCaptor.getValue().getIdentifier()); assertEquals(ActivityResourceType.PERSPECTIVE, resourceRefArgumentCaptor.getValue().getResourceType()); }
@Test public void testAuthorizeNegative() throws Exception { final String perspectiveId = "perspectiveId"; doReturn(false).when(authorizationManager).authorize(any(ResourceRef.class), eq(user)); assertFalse(shortcutHelper.authorize(perspectiveId)); }
|
Convert { public static ServerInstanceKey toKey( final ServerInstance serverInstance ) { return new ServerInstanceKey( serverInstance.getServerTemplateId(), serverInstance.getServerName(), serverInstance.getServerInstanceId(), serverInstance.getUrl() ); } private Convert(); static ServerInstanceKey toKey( final ServerInstance serverInstance ); }
|
@Test public void testToKey() { final String serverTemplateId = "serverTemplateId"; final String serverName = "serverName"; final String serverInstanceId = "serverInstanceId"; final String url = "url"; ServerInstance serverInstance = new ServerInstance( serverTemplateId, serverName, serverInstanceId, url, "version", new ArrayList<Message>(), new ArrayList<Container>() ); ServerInstanceKey key = Convert.toKey( serverInstance ); assertEquals( serverTemplateId, key.getServerTemplateId() ); assertEquals( serverName, key.getServerName() ); assertEquals( serverInstanceId, key.getServerInstanceId() ); assertEquals( url, key.getUrl() ); }
|
ServerManagementPerspective { public void onNewContainer( @Observes final AddNewContainer addNewContainer ) { if ( addNewContainer != null && addNewContainer.getServerTemplate() != null ) { newContainerWizard.clear(); newContainerWizard.setServerTemplate( addNewContainer.getServerTemplate() ); newContainerWizard.start(); } else { logger.warn( "Illegal event argument." ); } } @Inject ServerManagementPerspective( final Logger logger,
final NewServerTemplateWizard newServerTemplateWizard,
final NewContainerWizard newContainerWizard ); @Perspective PerspectiveDefinition buildPerspective(); void onNewTemplate( @Observes final AddNewServerTemplate addNewServerTemplate ); void onNewContainer( @Observes final AddNewContainer addNewContainer ); }
|
@Test public void testOnNewContainer() { final ServerTemplate template = mock( ServerTemplate.class ); perspective.onNewContainer( new AddNewContainer( template ) ); verify( newContainerWizard ).clear(); verify( newContainerWizard ).setServerTemplate( eq( template ) ); verify( newContainerWizard ).start(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.