method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
BaseViewPresenter { public void renameItem(final FolderItem folderItem) { final Path path = getFolderItemPath(folderItem); renamePopUpPresenter.show(path, new Validator() { @Override public void validate(final String value, final ValidatorCallback callback) { validationService.call(new RemoteCallback<Object>() { @Override public void callback(Object response) { if (Boolean.TRUE.equals(response)) { callback.onSuccess(); } else { callback.onFailure(); } } }) .isFileNameValid(path, value); } }, new CommandWithFileNameAndCommitMessage() { @Override public void execute(final FileNameAndCommitMessage details) { baseView.showBusyIndicator(CommonConstants.INSTANCE.Renaming()); explorerService.call( getRenameSuccessCallback(getRenameView()), getRenameErrorCallback(getRenameView()) ) .renameItem(folderItem, details.getNewFileName(), details.getCommitMessage()); } } ); } BaseViewPresenter(BaseViewImpl baseView); @PostConstruct void init(); void onActiveOptionsChange(final @Observes ActiveOptionsChangedEvent changedEvent); void update(); void refresh(); void loadContent(final FolderItem item); FolderListing getActiveContent(); void deleteItem(final FolderItem folderItem); void renameItem(final FolderItem folderItem); void copyItem(final FolderItem folderItem); void uploadArchivedFolder(final FolderItem folderItem); String getCurrentTag(); Set<String> getActiveContentTags(); void onModuleSelected(final Module module); void onActiveFolderItemSelected(final FolderItem item); void onItemSelected(final FolderItem folderItem); void setVisible(final boolean visible); void onTagFilterChanged(@Observes TagChangedEvent event); void onResourceUpdated(@Observes final ResourceUpdatedEvent event); void onResourceAdded(@Observes final ResourceAddedEvent event); void onResourceDeleted(@Observes final ResourceDeletedEvent event); void onResourceCopied(@Observes final ResourceCopiedEvent event); void onLockStatusChange(@Observes final LockInfo lockInfo); void initialiseViewForActiveContext(final WorkspaceProjectContext context); void initialiseViewForActiveContext(String initPath); void onResourceRenamed(@Observes final ResourceRenamedEvent event); boolean canShowTags(); }### Answer:
@Test public void testRenameNotification() { renamePopUpPresenterShowMock(); when(renamePopUpPresenterMock.getView()).thenReturn(renamePopUpView); final FolderItem item = mock(FolderItem.class); presenter.renameItem(item); verify(notification, times(1)).fire(any(NotificationEvent.class)); } |
### Question:
BaseViewPresenter { public void onActiveOptionsChange(final @Observes ActiveOptionsChangedEvent changedEvent) { final boolean isVisible = isViewVisible(); setVisible(isVisible); if (isVisible) { initialiseViewForActiveContext(context); } } BaseViewPresenter(BaseViewImpl baseView); @PostConstruct void init(); void onActiveOptionsChange(final @Observes ActiveOptionsChangedEvent changedEvent); void update(); void refresh(); void loadContent(final FolderItem item); FolderListing getActiveContent(); void deleteItem(final FolderItem folderItem); void renameItem(final FolderItem folderItem); void copyItem(final FolderItem folderItem); void uploadArchivedFolder(final FolderItem folderItem); String getCurrentTag(); Set<String> getActiveContentTags(); void onModuleSelected(final Module module); void onActiveFolderItemSelected(final FolderItem item); void onItemSelected(final FolderItem folderItem); void setVisible(final boolean visible); void onTagFilterChanged(@Observes TagChangedEvent event); void onResourceUpdated(@Observes final ResourceUpdatedEvent event); void onResourceAdded(@Observes final ResourceAddedEvent event); void onResourceDeleted(@Observes final ResourceDeletedEvent event); void onResourceCopied(@Observes final ResourceCopiedEvent event); void onLockStatusChange(@Observes final LockInfo lockInfo); void initialiseViewForActiveContext(final WorkspaceProjectContext context); void initialiseViewForActiveContext(String initPath); void onResourceRenamed(@Observes final ResourceRenamedEvent event); boolean canShowTags(); }### Answer:
@Test public void testOnActiveOptionsChange() throws Exception { presenter.onActiveOptionsChange(new ActiveOptionsChangedEvent()); verify(view).setVisible(true); isPresenterVisible = false; presenter.onActiveOptionsChange(new ActiveOptionsChangedEvent()); verify(view).setVisible(false); } |
### Question:
BaseViewPresenter { CopyPopUpPresenter.View getCopyView() { return copyPopUpPresenter.getView(); } BaseViewPresenter(BaseViewImpl baseView); @PostConstruct void init(); void onActiveOptionsChange(final @Observes ActiveOptionsChangedEvent changedEvent); void update(); void refresh(); void loadContent(final FolderItem item); FolderListing getActiveContent(); void deleteItem(final FolderItem folderItem); void renameItem(final FolderItem folderItem); void copyItem(final FolderItem folderItem); void uploadArchivedFolder(final FolderItem folderItem); String getCurrentTag(); Set<String> getActiveContentTags(); void onModuleSelected(final Module module); void onActiveFolderItemSelected(final FolderItem item); void onItemSelected(final FolderItem folderItem); void setVisible(final boolean visible); void onTagFilterChanged(@Observes TagChangedEvent event); void onResourceUpdated(@Observes final ResourceUpdatedEvent event); void onResourceAdded(@Observes final ResourceAddedEvent event); void onResourceDeleted(@Observes final ResourceDeletedEvent event); void onResourceCopied(@Observes final ResourceCopiedEvent event); void onLockStatusChange(@Observes final LockInfo lockInfo); void initialiseViewForActiveContext(final WorkspaceProjectContext context); void initialiseViewForActiveContext(String initPath); void onResourceRenamed(@Observes final ResourceRenamedEvent event); boolean canShowTags(); }### Answer:
@Test public void testGetCopyView() { when(copyPopUpPresenterMock.getView()).thenReturn(copyPopUpView); CopyPopUpPresenter.View view = presenter.getCopyView(); assertTrue(view instanceof CopyPopupWithPackageView); } |
### Question:
BaseViewPresenter { RenamePopUpPresenter.View getRenameView() { return renamePopUpPresenter.getView(); } BaseViewPresenter(BaseViewImpl baseView); @PostConstruct void init(); void onActiveOptionsChange(final @Observes ActiveOptionsChangedEvent changedEvent); void update(); void refresh(); void loadContent(final FolderItem item); FolderListing getActiveContent(); void deleteItem(final FolderItem folderItem); void renameItem(final FolderItem folderItem); void copyItem(final FolderItem folderItem); void uploadArchivedFolder(final FolderItem folderItem); String getCurrentTag(); Set<String> getActiveContentTags(); void onModuleSelected(final Module module); void onActiveFolderItemSelected(final FolderItem item); void onItemSelected(final FolderItem folderItem); void setVisible(final boolean visible); void onTagFilterChanged(@Observes TagChangedEvent event); void onResourceUpdated(@Observes final ResourceUpdatedEvent event); void onResourceAdded(@Observes final ResourceAddedEvent event); void onResourceDeleted(@Observes final ResourceDeletedEvent event); void onResourceCopied(@Observes final ResourceCopiedEvent event); void onLockStatusChange(@Observes final LockInfo lockInfo); void initialiseViewForActiveContext(final WorkspaceProjectContext context); void initialiseViewForActiveContext(String initPath); void onResourceRenamed(@Observes final ResourceRenamedEvent event); boolean canShowTags(); }### Answer:
@Test public void testGetRenameView() { when(renamePopUpPresenterMock.getView()).thenReturn(renamePopUpView); RenamePopUpPresenter.View view = presenter.getRenameView(); assertTrue(view instanceof RenamePopUpPresenter.View); } |
### Question:
ExplorerMenu { public void onRefresh() { refreshCommand.execute(); } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testOnRefresh() throws Exception { menu.onRefresh(); verify(refreshCommand).execute(); } |
### Question:
ExplorerMenu { public void refresh() { if (activeOptions.isTreeNavigatorVisible()) { view.showTreeNav(); } else { view.showBreadcrumbNav(); } if (activeOptions.isTechnicalViewActive()) { view.showTechViewIcon(); view.hideBusinessViewIcon(); } else { view.showBusinessViewIcon(); view.hideTechViewIcon(); } if (activeOptions.canShowTag()) { view.showTagFilterIcon(); } else { view.hideTagFilterIcon(); } } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testRefreshVersion1() throws Exception { when(activeOptions.isTechnicalViewActive()).thenReturn(true); when(activeOptions.isTreeNavigatorVisible()).thenReturn(true); when(activeOptions.canShowTag()).thenReturn(true); menu.refresh(); verify(view).showTreeNav(); verify(view).showTechViewIcon(); verify(view).hideBusinessViewIcon(); verify(view).showTagFilterIcon(); verify(view, never()).showBreadcrumbNav(); verify(view, never()).showBusinessViewIcon(); verify(view, never()).hideTechViewIcon(); verify(view, never()).hideTagFilterIcon(); }
@Test public void testRefreshVersion2() throws Exception { when(activeOptions.isTechnicalViewActive()).thenReturn(false); when(activeOptions.isTreeNavigatorVisible()).thenReturn(false); when(activeOptions.canShowTag()).thenReturn(false); menu.refresh(); verify(view, never()).showTreeNav(); verify(view, never()).showTechViewIcon(); verify(view, never()).hideBusinessViewIcon(); verify(view, never()).showTagFilterIcon(); verify(view).showBreadcrumbNav(); verify(view).showBusinessViewIcon(); verify(view).hideTechViewIcon(); verify(view).hideTagFilterIcon(); } |
### Question:
ExplorerMenu { public void onBreadCrumbExplorerSelected() { if (!activeOptions.isBreadCrumbNavigationVisible()) { activeOptions.activateBreadCrumbNavigation(); refresh(); updateCommand.execute(); } } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testOnBreadCrumbExplorerSelected() throws Exception { menu.onBreadCrumbExplorerSelected(); verify(activeOptions).activateBreadCrumbNavigation(); verify(updateCommand).execute(); } |
### Question:
ExplorerMenu { public void onTreeExplorerSelected() { if (!activeOptions.isTreeNavigatorVisible()) { activeOptions.activateTreeViewNavigation(); refresh(); updateCommand.execute(); } } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testOnTreeExplorerSelected() throws Exception { menu.onTreeExplorerSelected(); verify(activeOptions).activateTreeViewNavigation(); verify(updateCommand).execute(); } |
### Question:
ExplorerMenu { public void onShowTagFilterSelected() { if (activeOptions.canShowTag()) { activeOptions.disableTagFiltering(); } else { activeOptions.activateTagFiltering(); } refresh(); updateCommand.execute(); } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testOnShowTagFilterSelectedOn() throws Exception { when(activeOptions.canShowTag()).thenReturn(false); menu.onShowTagFilterSelected(); verify(activeOptions).activateTagFiltering(); verify(updateCommand).execute(); }
@Test public void testOnShowTagFilterSelectedOff() throws Exception { when(activeOptions.canShowTag()).thenReturn(true); menu.onShowTagFilterSelected(); verify(activeOptions).disableTagFiltering(); verify(updateCommand).execute(); } |
### Question:
MoveColumnsCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new AbstractGraphCommand() { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext context) { return isColumnInValidSection() ? GraphCommandResultBuilder.SUCCESS : GraphCommandResultBuilder.failed(); } private boolean isColumnInValidSection() { final RelationSection section = RelationUIModelMapperHelper.getSection(relation, index); return section == RelationSection.INFORMATION_ITEM; } @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { return moveInformationItems(index); } @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { return moveInformationItems(oldIndex); } private CommandResult<RuleViolation> moveInformationItems(final int index) { final RelationSection section = RelationUIModelMapperHelper.getSection(relation, index); if (section == RelationSection.INFORMATION_ITEM) { final int oldIndex = uiModel.getColumns().indexOf(columns.get(0)); final int relativeIndex = RelationUIModelMapperHelper.getInformationItemIndex(relation, index); final int relativeOldIndex = RelationUIModelMapperHelper.getInformationItemIndex(relation, oldIndex); final java.util.List<Integer> informationItemIndexesToMove = columns .stream() .map(c -> uiModel.getColumns().indexOf(c)) .map(i -> RelationUIModelMapperHelper.getInformationItemIndex(relation, i)) .collect(Collectors.toList()); moveInformationItems(relativeIndex, relativeOldIndex, relation.getColumn(), informationItemIndexesToMove); CommandUtils.moveComponentWidths(Relation.STATIC_COLUMNS + relativeIndex, Relation.STATIC_COLUMNS + relativeOldIndex, relation.getComponentWidths(), Collections.singletonList(oldIndex)); updateRowsData(relativeIndex, relativeOldIndex, relation.getRow(), informationItemIndexesToMove); return GraphCommandResultBuilder.SUCCESS; } else { return GraphCommandResultBuilder.failed(); } } private <T> void moveInformationItems(final int relativeIndex, final int relativeOldIndex, final java.util.List<T> informationItems, final java.util.List<Integer> informationItemIndexesToMove) { final java.util.List<T> informationItemsToMove = informationItemIndexesToMove .stream() .map(informationItems::get) .collect(Collectors.toList()); informationItems.removeAll(informationItemsToMove); if (relativeIndex < relativeOldIndex) { informationItems.addAll(relativeIndex, informationItemsToMove); } else if (relativeIndex > relativeOldIndex) { informationItems.addAll(relativeIndex - informationItemsToMove.size() + 1, informationItemsToMove); } } private void updateRowsData(final int relativeIndex, final int relativeOldIndex, final java.util.List<List> rows, final java.util.List<Integer> informationItemIndexesToMove) { rows.forEach(row -> moveInformationItems(relativeIndex, relativeOldIndex, row.getExpression(), informationItemIndexesToMove)); } }; } MoveColumnsCommand(final Relation relation,
final DMNGridData uiModel,
final int index,
final java.util.List<GridColumn<?>> columns,
final org.uberfire.mvp.Command canvasOperation); void updateParentInformation(); }### Answer:
@Test public void testGraphCommandAllow() { setupCommand(0, uiModel.getColumns().get(0)); final Command<GraphCommandExecutionContext, RuleViolation> c = command.newGraphCommand(handler); assertEquals(CommandResult.Type.ERROR, c.allow(gce).getType()); }
@Test public void testGraphCommandExecuteMoveLeft() { setupCommand(1, uiModel.getColumns().get(2)); assertEquals(GraphCommandResultBuilder.SUCCESS, command.newGraphCommand(handler).execute(gce)); assertRelationDefinition(1, 0); }
@Test public void testGraphCommandExecuteMoveRight() { setupCommand(2, uiModel.getColumns().get(1)); assertEquals(GraphCommandResultBuilder.SUCCESS, command.newGraphCommand(handler).execute(gce)); assertRelationDefinition(1, 0); } |
### Question:
ExplorerMenu { public void onArchiveActiveProject() { view.archive(context.getActiveModule() .map(module -> module.getRootPath()) .orElseThrow(() -> new IllegalStateException("Cannot get root path without active module."))); } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testOnArchiveActiveModule() throws Exception { final Path rootModulePath = mock(Path.class); final POM pom = mock(POM.class); when(pom.getName()).thenReturn("my module"); final Module module = new Module(rootModulePath, mock(Path.class), pom); when(context.getActiveModule()).thenReturn(Optional.of(module)); menu.onArchiveActiveProject(); verify(view).archive(rootModulePath); } |
### Question:
ExplorerMenu { public void onArchiveActiveRepository() { final Optional<Branch> defaultBranch = context.getActiveWorkspaceProject() .map(proj -> proj.getRepository()) .orElseThrow(() -> new IllegalStateException("Cannot check for default branch without an active project.")) .getDefaultBranch(); if (defaultBranch.isPresent()) { view.archive(defaultBranch.get().getPath()); } } ExplorerMenu(); @Inject ExplorerMenu(final ExplorerMenuView view,
final ActiveContextOptions activeOptions,
final WorkspaceProjectContext projectContext); Menus asMenu(); void refresh(); void addRefreshCommand(Command refreshCommand); void addUpdateCommand(Command updateCommand); void onBusinessViewSelected(); void onTechViewSelected(); void onTreeExplorerSelected(); void onBreadCrumbExplorerSelected(); void onShowTagFilterSelected(); void onArchiveActiveProject(); void onArchiveActiveRepository(); void onRefresh(); }### Answer:
@Test public void testOnArchiveActiveRepo() throws Exception { final Path rootRepoPath = mock(Path.class); final Repository repository = mock(Repository.class); when(repository.getDefaultBranch()).thenReturn(Optional.of(new Branch("master", rootRepoPath))); final WorkspaceProject project = mock(WorkspaceProject.class); when(project.getRepository()).thenReturn(repository); when(context.getActiveWorkspaceProject()).thenReturn(Optional.of(project)); menu.onArchiveActiveRepository(); verify(view).archive(rootRepoPath); } |
### Question:
ExplorerPresenter { private void refresh() { getActiveView().refresh(); } ExplorerPresenter(); @Inject ExplorerPresenter(final ExplorerView view,
final BusinessViewPresenter businessViewPresenter,
final TechnicalViewPresenter technicalViewPresenter,
final WorkspaceProjectContext context,
final ActiveContextOptions activeOptions,
final ExplorerMenu menu); @OnStartup void onStartup(final PlaceRequest placeRequest); @WorkbenchPartView UberView<ExplorerPresenter> getView(); @WorkbenchPartTitle String getTitle(); @DefaultPosition Position getDefaultPosition(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); public ExplorerMenu menu; }### Answer:
@Test public void testTechViewRefresh() throws Exception { ArgumentCaptor<Command> argumentCaptor = ArgumentCaptor.forClass( Command.class ); when( activeOptions.isTechnicalViewActive() ).thenReturn( true ); verify( menu ).addRefreshCommand( argumentCaptor.capture() ); argumentCaptor.getValue().execute(); verify( technicalViewPresenter ).refresh(); verify( businessViewPresenter, never() ).refresh(); }
@Test public void testBusinessViewRefresh() throws Exception { ArgumentCaptor<Command> argumentCaptor = ArgumentCaptor.forClass( Command.class ); when( activeOptions.isBusinessViewActive() ).thenReturn( true ); verify( menu ).addRefreshCommand( argumentCaptor.capture() ); argumentCaptor.getValue().execute(); verify( technicalViewPresenter, never() ).refresh(); verify( businessViewPresenter ).refresh(); } |
### Question:
ExplorerPresenter { private void update() { getActiveView().update(); } ExplorerPresenter(); @Inject ExplorerPresenter(final ExplorerView view,
final BusinessViewPresenter businessViewPresenter,
final TechnicalViewPresenter technicalViewPresenter,
final WorkspaceProjectContext context,
final ActiveContextOptions activeOptions,
final ExplorerMenu menu); @OnStartup void onStartup(final PlaceRequest placeRequest); @WorkbenchPartView UberView<ExplorerPresenter> getView(); @WorkbenchPartTitle String getTitle(); @DefaultPosition Position getDefaultPosition(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); public ExplorerMenu menu; }### Answer:
@Test public void testTechViewUpdate() throws Exception { ArgumentCaptor<Command> argumentCaptor = ArgumentCaptor.forClass( Command.class ); when( activeOptions.isTechnicalViewActive() ).thenReturn( true ); verify( menu ).addUpdateCommand( argumentCaptor.capture() ); argumentCaptor.getValue().execute(); verify( technicalViewPresenter ).update(); verify( businessViewPresenter, never() ).update(); }
@Test public void testBusinessViewUpdate() throws Exception { ArgumentCaptor<Command> argumentCaptor = ArgumentCaptor.forClass( Command.class ); when( activeOptions.isBusinessViewActive() ).thenReturn( true ); verify( menu ).addUpdateCommand( argumentCaptor.capture() ); argumentCaptor.getValue().execute(); verify( technicalViewPresenter, never() ).update(); verify( businessViewPresenter ).update(); } |
### Question:
Classifier { public ClientResourceType findResourceType( final FolderItem folderItem ) { if ( folderItem.getItem() instanceof Path ) { return findResourceType( (Path) folderItem.getItem() ); } throw new IllegalArgumentException( "Invalid FolderItem type." ); } @PostConstruct void init(); Map<ClientResourceType, Collection<FolderItem>> group( final Collection<FolderItem> folderItems ); ClientResourceType findResourceType( final FolderItem folderItem ); ClientResourceType findResourceType( final Path path ); }### Answer:
@Test public void successfullyFindResourceTypeByPathTest() { final Path path = mock( Path.class ); doReturn( true ).when( clientResourceType ).accept( path ); final ClientResourceType resourceType = classifier.findResourceType( path ); assertNotNull( resourceType ); assertEquals( clientResourceType, resourceType ); }
@Test(expected = IllegalArgumentException.class) public void unsuccessfullyFindResourceTypeByPathTest() { final Path path = mock( Path.class ); doReturn( false ).when( clientResourceType ).accept( path ); classifier.findResourceType( path ); }
@Test public void successfullyFindResourceTypeByFolderItemTest() { final FolderItem folderItem = mock( FolderItem.class ); final Path path = mock( Path.class ); doReturn( path ).when( folderItem ).getItem(); doReturn( true ).when( clientResourceType ).accept( path ); final ClientResourceType resourceType = classifier.findResourceType( folderItem ); assertNotNull( resourceType ); assertEquals( clientResourceType, resourceType ); }
@Test(expected = IllegalArgumentException.class) public void unsuccessfullyFindResourceTypeByFolderItemTest() { final FolderItem folderItem = mock( FolderItem.class ); final Path path = mock( Path.class ); doReturn( path ).when( folderItem ).getItem(); doReturn( false ).when( clientResourceType ).accept( path ); classifier.findResourceType( folderItem ); } |
### Question:
Utils { public static String getBaseFileName(final String fileName, final String suffix) { final int suffixIndex = fileName.lastIndexOf("." + suffix); return (suffixIndex > 0 ? fileName.substring(0, suffixIndex) : fileName); } static boolean hasOrganizationalUnitChanged(final OrganizationalUnit organizationalUnit,
final OrganizationalUnit activeOrganizationalUnit); static boolean hasProjectChanged(final WorkspaceProject project,
final WorkspaceProject activeProject); static boolean hasBranchChanged(final String branch,
final String activeBranch); static boolean hasModuleChanged(final Module module,
final Module activeModule); static boolean hasPackageChanged(final Package pkg,
final Package activePackage); static boolean hasRepositoryChanged(final Repository repository,
final Repository activeRepository); static boolean hasRepositoryChanged(final WorkspaceProject workspaceProject,
final WorkspaceProject activeWorkspaceProject); static boolean hasFolderItemChanged(final FolderItem item,
final FolderItem activeItem); static FolderItem makeFileItem(final Path path); static FolderItem makeFolderItem(final Path path); static boolean isInBranch(final Path branchRootPath,
final Module module); static boolean isInModule(final Module module,
final Package pkg); static boolean isInFolderItem(final FolderItem folderItem,
final Path resource); static boolean isInPackage(final Package pkg,
final Path resource); static boolean isLeaf(final Path child,
final Path parent); static boolean isSibling(final Path child,
final Path parent); static String getBaseFileName(final String fileName,
final String suffix); }### Answer:
@Test public void getBaseFileNameSimpleExtension() { when( clientResourceType.getSuffix() ).thenReturn( "xml" ); String result = Utils.getBaseFileName( "filename.xml", clientResourceType.getSuffix() ); assertEquals( "filename", result ); }
@Test public void getBaseFileNameComplexExtension() { when( clientResourceType.getSuffix() ).thenReturn( "suffix.xml" ); String result = Utils.getBaseFileName( "filename.suffix.xml", clientResourceType.getSuffix() ); assertEquals( "filename", result ); } |
### Question:
ProjectExplorerContentResolver { public ProjectExplorerContent resolve(final ProjectExplorerContentQuery query) { final Content content = setupSelectedItems(query); setSelectedModule(content); setSelectedPackage(content); setSelectedItem(content); if (content.getSelectedProject() == null || content.getSelectedModule() == null) { return emptyModuleExplorerContent(content); } else { return moduleExplorerContentWithSelections(content, query.getOptions()); } } @Inject ProjectExplorerContentResolver(final KieModuleService moduleService,
final ExplorerServiceHelper helper,
final ExplorerServiceHelper explorerServiceHelper,
final WorkspaceProjectService projectService); ProjectExplorerContent resolve(final ProjectExplorerContentQuery query); }### Answer:
@Test public void testResolveWithOUWithRepositoryNullQueryBusinessView() throws Exception { final ProjectExplorerContentQuery query = new ProjectExplorerContentQuery(repository, masterBranch); final ActiveOptions options = new ActiveOptions(); options.add(Option.TREE_NAVIGATOR); options.add(Option.EXCLUDE_HIDDEN_ITEMS); options.add(Option.BUSINESS_CONTENT); query.setOptions(options); resolver.resolve(query); }
@Test public void testResolveWithOUWithRepositoryNullQueryTechnicalView() throws Exception { final ProjectExplorerContentQuery query = new ProjectExplorerContentQuery(repository, masterBranch); final ActiveOptions options = new ActiveOptions(); options.add(Option.TREE_NAVIGATOR); options.add(Option.EXCLUDE_HIDDEN_ITEMS); options.add(Option.TECHNICAL_CONTENT); query.setOptions(options); resolver.resolve(query); } |
### Question:
ProjectExplorerContentResolver { List<FolderItem> getSegmentSiblings(final Path path) { final List<FolderItem> result = new ArrayList<>(); final org.uberfire.java.nio.file.Path nioPath = Paths.convert(path); if (nioPath.equals(nioPath.getRoot())) { result.add(explorerServiceHelper.toFolderItem(nioPath)); } else { final org.uberfire.java.nio.file.Path nioParentPath = nioPath.getParent(); for (org.uberfire.java.nio.file.Path sibling : getDirectoryIterator(nioParentPath)) { result.add(explorerServiceHelper.toFolderItem(sibling)); } } return result; } @Inject ProjectExplorerContentResolver(final KieModuleService moduleService,
final ExplorerServiceHelper helper,
final ExplorerServiceHelper explorerServiceHelper,
final WorkspaceProjectService projectService); ProjectExplorerContent resolve(final ProjectExplorerContentQuery query); }### Answer:
@Test public void getSegmentSiblingsRootTest() { 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(explorerServiceHelper).toFolderItem(any(org.uberfire.java.nio.file.Path.class)); Path path = PathFactory.newPath("/", "default: final List<FolderItem> siblings = resolver.getSegmentSiblings(path); assertEquals(1, siblings.size()); assertEquals("/", siblings.get(0).getFileName()); }
@Test public void getSegmentSiblingsTest() { 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(explorerServiceHelper).toFolderItem(any(org.uberfire.java.nio.file.Path.class)); Path path = PathFactory.newPath("src", "default: final List<org.uberfire.java.nio.file.Path> mockedSiblings = new ArrayList<>(); mockedSiblings.add(Paths.convert(path)); mockedSiblings.add(Paths.convert(PathFactory.newPath("src", "default: doReturn(mockedSiblings).when(resolver).getDirectoryIterator(any(org.uberfire.java.nio.file.Path.class)); final List<FolderItem> siblings = resolver.getSegmentSiblings(path); assertEquals(2, siblings.size()); assertEquals("src", siblings.get(0).getFileName()); assertEquals("pom.xml", siblings.get(1).getFileName()); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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; }### Answer:
@Test public void testAcceptMessage( ) { assertTrue( translator.accept( originalMessage ) ); assertFalse( translator.accept( new ValidationMessage( ) ) ); } |
### Question:
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; }### Answer:
@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 ) ); } |
### Question:
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(); }### Answer:
@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() ); } |
### Question:
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(); }### Answer:
@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( ) ); } |
### Question:
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); }### Answer:
@Test public void testAsWidget() { Widget widget = mock(Widget.class); when(view.asWidget()).thenReturn(widget); assertEquals(widget, dialog.asWidget()); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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(); }### Answer:
@Test public void testCanvasCommandAllow() { setupCommand(0, uiModel.getColumns().get(0)); final Command<AbstractCanvasHandler, CanvasViolation> c = command.newCanvasCommand(handler); assertEquals(CanvasCommandResultBuilder.SUCCESS, c.allow(handler)); } |
### Question:
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); }### Answer:
@Test public void testGetStringValue() { testGetStringValue(NAME_VALUE, NAME_VALUE); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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); }### Answer:
@Test public void testOnCancel() { dialog.onCancel(); verify(view).hide(); } |
### Question:
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); }### Answer:
@Test public void testAsWidget() { Widget widget = mock(Widget.class); when(view.asWidget()).thenReturn(widget); assertEquals(widget, dialog.asWidget()); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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); }### Answer:
@Test public void testGetStringValue() { testGetStringValue("someValue", "someValue"); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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); }### Answer:
@Test public void testOnCancel() { dialog.onCancel(); verify(view).hide(); } |
### Question:
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); }### Answer:
@Test public void testAsWidget() { Widget widget = mock(Widget.class); when(view.asWidget()).thenReturn(widget); assertEquals(widget, dialog.asWidget()); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void testGetStringValue() { testGetStringValue("someValue", "someValue"); } |
### Question:
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); }### Answer:
@Test public void testOnCancel() { dialog.onCancel(); verify(view).hide(); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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() ); } |
### Question:
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(); }### Answer:
@Test public void loadDataObjectTest() { JPADataObjectEditor objectEditor = createObjectEditor(); objectEditor.onContextChange( context ); verify( view, times( 2 ) ).loadPropertyEditorCategories( anyListOf( PropertyEditorCategory.class ) ); assertFalse( objectEditor.isReadonly() ); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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"); } |
### Question:
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); }### Answer:
@Test public void testClear() { annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); annotationListEditor.clear(); verify(view, times(2)).clear(); verifyItemsCleared(); } |
### Question:
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); }### Answer:
@Test public void testDestroy() { annotationListEditor.loadAnnotations(annotations, annotationSourcesMap); annotationListEditor.destroy(); verifyItemsCleared(); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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( ); }### Answer:
@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 ) ); } } |
### Question:
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( ); }### Answer:
@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 ); } |
### Question:
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( ); }### Answer:
@Test public void testOnCollapseChange( ) { listItem.setCollapseChangeHandler( collapseChangeHandler ); listItem.onCollapseChange( ); verify( collapseChangeHandler, times( 1 ) ).onCollapseChange( ); } |
### Question:
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( ); }### Answer:
@Test public void testOnDelete( ) { listItem.loadAnnotation( annotation, annotationSource ); listItem.setDeleteAnnotationHandler( deleteAnnotationHandler ); listItem.onDelete( ); verify( deleteAnnotationHandler, times( 1 ) ).onDeleteAnnotation( annotation ); } |
### Question:
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; }### Answer:
@Test public void testGetSortOrder() { final Sort expected = new Sort(new SortField(FILE_NAME_FIELD_SORTED, STRING)); final Sort actual = query.getSortOrder(); assertEquals(expected, actual); } |
### Question:
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( ); }### Answer:
@Test public void testDestroy() { listItem.loadAnnotation( annotation, annotationSource ); listItem.destroy(); for ( AnnotationValuePairListItem valuePairItem : valuePairItems ) { verify( itemInstance, times( 1 ) ).destroy( valuePairItem ); } } |
### Question:
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( ); }### Answer:
@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( ) ); } |
### Question:
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( ); }### Answer:
@Test public void testOnEdit( ) { listItem.setEditValuePairHandler( editValuePairHandler ); listItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); listItem.onEdit( ); verify( editValuePairHandler, times( 1 ) ).onEditValuePair( annotation, VALUE_PAIR_NAME ); } |
### Question:
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( ); }### Answer:
@Test public void testOnClear( ) { listItem.setClearValuePairHandler( clearValuePairHandler ); listItem.loadValuePair( annotation, valuePairDefinition, annotationSource ); listItem.onClear( ); verify( clearValuePairHandler, times( 1 ) ).onClearValuePair( annotation, VALUE_PAIR_NAME ); } |
### Question:
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( ); }### Answer:
@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 ); } |
### Question:
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(); }### Answer:
@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 ); } |
### Question:
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(); }### Answer:
@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( "{}" ) ); } |
### Question:
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(); }### Answer:
@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 ); } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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 ); }### Answer:
@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 ); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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); }### Answer:
@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(); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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(); }### Answer:
@Test public void testCanvasCommandAllow() { final Command<AbstractCanvasHandler, CanvasViolation> c = command.newCanvasCommand(handler); assertEquals(CanvasCommandResultBuilder.SUCCESS, c.allow(handler)); } |
### Question:
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; }### Answer:
@Test public void testShowDocks() { presenter.showDocks(); verify(docks).show(); verify(dataModelerFocusEvent).fire(any()); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@Test public void testOnLoadClassWithClassAndNotNullHandler() { when(view.getNewClassName()).thenReturn("NewClassName"); presenter.onLoadClass(); verify(mockLoadClassesHandler).onLoadClass("NewClassName"); } |
### Question:
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(); }### Answer:
@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() ); } |
### Question:
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(); }### Answer:
@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 ) ); } |
### Question:
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(); }### Answer:
@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() ); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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; }### Answer:
@Test public void readFromXMLTest() { try { PersistenceDescriptorModel descriptor = PersistenceDescriptorXMLMarshaller.fromXML( getInputStream( "persistence.xml" ), false ); assertEqualsDescriptor( expectedDescriptor(), descriptor ); } catch ( Exception e ) { fail( e.getMessage() ); } } |
### Question:
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 ); }### Answer:
@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 ) ); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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 ); }### Answer:
@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 ) ); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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); }### Answer:
@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()))); } |
### Question:
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); }### Answer:
@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)); } } |
### Question:
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); }### Answer:
@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)); } } |
### Question:
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); }### Answer:
@Test public void testMakeCommentedOption() { String message = "message"; CommentedOption commentedOption = mock(CommentedOption.class); when(commentedOptionFactory.makeCommentedOption(message)).thenReturn(commentedOption); assertEquals(commentedOption, serviceHelper.makeCommentedOption(message)); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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()))); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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); }### Answer:
@Test public void testFillIndexBuilderWithUnavailablePath() throws Exception { final Path mockPath = mock(Path.class); when(ioService.exists(mockPath)).thenReturn(false); assertNull(indexer.fillIndexBuilder(mockPath)); } |
### Question:
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); }### Answer:
@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")); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.