method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
ProjectDiagramResourceServiceImpl implements ProjectDiagramResourceService { @Override public Path saveAndRename(final Path path, final String newFileName, final Metadata metadata, final ProjectDiagramResource resource, final String comment) { return saveAndRenameService.saveAndRename(path, newFileName, metadata, resource, comment); } ProjectDiagramResourceServiceImpl(); @Inject ProjectDiagramResourceServiceImpl(final ProjectDiagramService projectDiagramService,
final RenameService renameService,
final SaveAndRenameServiceImpl<ProjectDiagramResource, Metadata> saveAndRenameService); @PostConstruct void init(); @Override Path save(final Path path,
final ProjectDiagramResource resource,
final Metadata metadata,
final String comment); @Override Path rename(final Path path,
final String newName,
final String comment); @Override Path saveAndRename(final Path path,
final String newFileName,
final Metadata metadata,
final ProjectDiagramResource resource,
final String comment); }### Answer:
@Test public void testSaveAndRename() { final Path path = mock(Path.class); final Metadata metadata = mock(Metadata.class); final ProjectDiagramResourceImpl resource = mock(ProjectDiagramResourceImpl.class); final String newName = "newName"; final String comment = "comment"; service.saveAndRename(path, newName, metadata, resource, comment); verify(saveAndRenameService).saveAndRename(path, newName, metadata, resource, comment); } |
### Question:
ProjectDiagramServiceController extends AbstractVFSDiagramService<ProjectMetadata, ProjectDiagram> { @Override public ProjectDiagram getDiagramByPath(Path file) { final ProjectDiagram projectDiagram = super.getDiagramByPath(file); final org.uberfire.java.nio.file.Path svgPath = getDiagramSvgFilePath(projectDiagram); if (getIoService().exists(svgPath)) { projectDiagram.getMetadata().setDiagramSVGPath(Paths.convert(svgPath)); final String svgContent = getIoService().readAllString(svgPath); if (svgContent != null && svgContent.contains("xmlns:oryx=\"http: projectDiagram.getMetadata().setDiagramSVGGenerator(ProjectMetadata.SVGGenerator.JBPM_DESIGNER); } else { projectDiagram.getMetadata().setDiagramSVGGenerator(ProjectMetadata.SVGGenerator.STUNNER); } } return projectDiagram; } ProjectDiagramServiceController(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final IOService ioService,
final BackendRegistryFactory registryFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @Override Path create(final Path path,
final String name,
final String defSetId); Path create(final Path path,
final String name,
final String defSetId,
final String moduleName,
final Package projectPkg,
final Optional<String> projectType); @Override ProjectDiagram getDiagramByPath(Path file); Path save(final Path path,
final ProjectDiagram diagram,
final Map<String, ?> attributes,
final OpenOption... comment); Path saveAsXml(final Path path,
final String xml,
final Map<String, ?> attributes,
final OpenOption... comment); boolean delete(final Path _path,
final String message); }### Answer:
@Test @Override public void testGetDiagramByPath() throws IOException { final Path path = mockGetDiagramByPathObjects(); prepareLoadDiagramByPath(path); final Diagram result = diagramService.getDiagramByPath(path); assertEquals(diagram, result); verifyExpectedResult(path, result, null, null); }
@Test public void testGetDiagramByPathWhenStunnerSVGFileExists() throws IOException { final Path path = mockGetDiagramByPathObjects(); final Path expectedSVGPath = prepareSVGFile(path, DIAGRAM_SVG); prepareLoadDiagramByPath(path); final Diagram result = diagramService.getDiagramByPath(path); assertEquals(diagram, result); verifyExpectedResult(path, result, expectedSVGPath, ProjectMetadata.SVGGenerator.STUNNER); }
@Test public void testGetDiagramByPathWhenStunnerJBPMFileExists() throws IOException { final Path path = mockGetDiagramByPathObjects(); final Path expectedSVGPath = prepareSVGFile(path, JBPM_DIAGRAM_SVG); prepareLoadDiagramByPath(path); final Diagram result = diagramService.getDiagramByPath(path); assertEquals(diagram, result); verifyExpectedResult(path, result, expectedSVGPath, ProjectMetadata.SVGGenerator.JBPM_DESIGNER); } |
### Question:
ProjectDiagramServiceController extends AbstractVFSDiagramService<ProjectMetadata, ProjectDiagram> { public Path saveAsXml(final Path path, final String xml, final Map<String, ?> attributes, final OpenOption... comment) { try { getIoService().write(Paths.convert(path), xml, attributes, comment); } catch (Exception e) { LOG.error("Error while saving diagram.", e); throw new RuntimeException(e); } return path; } ProjectDiagramServiceController(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final IOService ioService,
final BackendRegistryFactory registryFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @Override Path create(final Path path,
final String name,
final String defSetId); Path create(final Path path,
final String name,
final String defSetId,
final String moduleName,
final Package projectPkg,
final Optional<String> projectType); @Override ProjectDiagram getDiagramByPath(Path file); Path save(final Path path,
final ProjectDiagram diagram,
final Map<String, ?> attributes,
final OpenOption... comment); Path saveAsXml(final Path path,
final String xml,
final Map<String, ?> attributes,
final OpenOption... comment); boolean delete(final Path _path,
final String message); }### Answer:
@Test public void testSaveAsXml() { final Path path = mock(Path.class); final String xml = "xml"; final Map<String, ?> attributes = Collections.singletonMap("key", "value"); final CommentedOption option = mock(CommentedOption.class); when(path.toURI()).thenReturn(FILE_URI); final org.uberfire.java.nio.file.Path expectedNioPath = Paths.convert(path); ((ProjectDiagramServiceController) diagramService).saveAsXml(path, xml, attributes, option); verify(ioService, times(1)).write(eq(expectedNioPath), eq(xml), eq(attributes), eq(option)); } |
### Question:
ProjectDiagramServiceController extends AbstractVFSDiagramService<ProjectMetadata, ProjectDiagram> { public boolean delete(final Path _path, final String message) { final org.uberfire.java.nio.file.Path path = Paths.convert(_path); return getIoService().deleteIfExists(path, StandardDeleteOption.NON_EMPTY_DIRECTORIES); } ProjectDiagramServiceController(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final IOService ioService,
final BackendRegistryFactory registryFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @Override Path create(final Path path,
final String name,
final String defSetId); Path create(final Path path,
final String name,
final String defSetId,
final String moduleName,
final Package projectPkg,
final Optional<String> projectType); @Override ProjectDiagram getDiagramByPath(Path file); Path save(final Path path,
final ProjectDiagram diagram,
final Map<String, ?> attributes,
final OpenOption... comment); Path saveAsXml(final Path path,
final String xml,
final Map<String, ?> attributes,
final OpenOption... comment); boolean delete(final Path _path,
final String message); }### Answer:
@Test public void testDelete() { Path path = mock(Path.class); when(path.toURI()).thenReturn(FILE_URI); when(metadata.getPath()).thenReturn(path); org.uberfire.java.nio.file.Path expectedNioPath = Paths.convert(path); diagramService.delete(diagram); verify(ioService, times(1)).deleteIfExists(eq(expectedNioPath), any(DeleteOption.class)); } |
### Question:
DelegateDiagramService implements DiagramService { @Override @SuppressWarnings("unchecked") public Diagram<Graph, Metadata> getDiagramByPath(final Path path) { return convert(projectDiagramService.getDiagramByPath(path)); } @Inject DelegateDiagramService(final ProjectDiagramService projectDiagramService); @Override @SuppressWarnings("unchecked") Diagram<Graph, Metadata> getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram); @Override boolean delete(final Diagram<Graph, Metadata> diagram); @Override String getRawContent(final Diagram<Graph, Metadata> diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); }### Answer:
@Test public void getDiagramByPath() { Diagram<Graph, Metadata> diagram = delegateDiagramService.getDiagramByPath(path); verify(projectDiagramService).getDiagramByPath(path); assertEqualDiagram(diagram); } |
### Question:
DelegateDiagramService implements DiagramService { @Override public boolean accepts(final Path path) { return projectDiagramService.accepts(path); } @Inject DelegateDiagramService(final ProjectDiagramService projectDiagramService); @Override @SuppressWarnings("unchecked") Diagram<Graph, Metadata> getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram); @Override boolean delete(final Diagram<Graph, Metadata> diagram); @Override String getRawContent(final Diagram<Graph, Metadata> diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); }### Answer:
@Test public void accepts() { boolean accepts = delegateDiagramService.accepts(path); verify(projectDiagramService).accepts(path); assertTrue(accepts); } |
### Question:
DelegateDiagramService implements DiagramService { @Override public Path create(final Path path, final String name, final String defSetId) { return projectDiagramService.create(path, name, defSetId); } @Inject DelegateDiagramService(final ProjectDiagramService projectDiagramService); @Override @SuppressWarnings("unchecked") Diagram<Graph, Metadata> getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram); @Override boolean delete(final Diagram<Graph, Metadata> diagram); @Override String getRawContent(final Diagram<Graph, Metadata> diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); }### Answer:
@Test public void create() { Path createdPath = delegateDiagramService.create(this.path, NAME, DEF_ID); verify(projectDiagramService).create(this.path, NAME, DEF_ID); assertEquals(createdPath, path); } |
### Question:
DelegateDiagramService implements DiagramService { @Override public Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram) { return projectDiagramService.saveOrUpdate(convert(diagram)); } @Inject DelegateDiagramService(final ProjectDiagramService projectDiagramService); @Override @SuppressWarnings("unchecked") Diagram<Graph, Metadata> getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram); @Override boolean delete(final Diagram<Graph, Metadata> diagram); @Override String getRawContent(final Diagram<Graph, Metadata> diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); }### Answer:
@Test public void saveOrUpdate() { Metadata metadata = delegateDiagramService.saveOrUpdate(diagram); verify(projectDiagramService).saveOrUpdate(projectDiagramArgumentCaptor.capture()); assertEqualDiagram(projectDiagramArgumentCaptor.getValue()); assertEquals(metadata, projectMetadata); } |
### Question:
DelegateDiagramService implements DiagramService { @Override public boolean delete(final Diagram<Graph, Metadata> diagram) { return projectDiagramService.delete(convert(diagram)); } @Inject DelegateDiagramService(final ProjectDiagramService projectDiagramService); @Override @SuppressWarnings("unchecked") Diagram<Graph, Metadata> getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram); @Override boolean delete(final Diagram<Graph, Metadata> diagram); @Override String getRawContent(final Diagram<Graph, Metadata> diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); }### Answer:
@Test public void delete() { boolean deleted = delegateDiagramService.delete(diagram); verify(projectDiagramService).delete(projectDiagramArgumentCaptor.capture()); assertEqualDiagram(projectDiagramArgumentCaptor.getValue()); assertTrue(deleted); } |
### Question:
DelegateDiagramService implements DiagramService { @Override public String getRawContent(final Diagram<Graph, Metadata> diagram) { return projectDiagramService.getRawContent(convert(diagram)); } @Inject DelegateDiagramService(final ProjectDiagramService projectDiagramService); @Override @SuppressWarnings("unchecked") Diagram<Graph, Metadata> getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Metadata saveOrUpdate(final Diagram<Graph, Metadata> diagram); @Override boolean delete(final Diagram<Graph, Metadata> diagram); @Override String getRawContent(final Diagram<Graph, Metadata> diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); }### Answer:
@Test public void getRawContent() { String rawContent = delegateDiagramService.getRawContent(diagram); verify(projectDiagramService).getRawContent(projectDiagramArgumentCaptor.capture()); assertEquals(rawContent, CONTENT); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public ProjectDiagram getDiagramByPath(final Path path) { return controller.getDiagramByPath(path); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testGetDiagramByPath() { when(diagramServiceController.getDiagramByPath(path)).thenReturn(diagram); ProjectDiagram result = diagramService.getDiagramByPath(path); verify(diagramServiceController, times(1)).getDiagramByPath(path); assertEquals(result, diagram); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public boolean accepts(final Path path) { return controller.accepts(path); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testAccepts() { when(diagramServiceController.accepts(path)).thenReturn(true); boolean result = diagramService.accepts(path); verify(diagramServiceController, times(1)).accepts(path); assertEquals(true, result); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public Path create(final Path path, final String name, final String defSetId, final String projectName, final Package projectPkg, final Optional<String> projectType) { return controller.create(path, name, defSetId, projectName, projectPkg, projectType); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testCreate() { when(diagramServiceController.create(path, NAME, DEF_SET_ID, PROJECT, PACKAGE, projectType)).thenReturn(resultPath); Path result = diagramService.create(path, NAME, DEF_SET_ID, PROJECT, PACKAGE, projectType); verify(diagramServiceController, times(1)).create(path, NAME, DEF_SET_ID, PROJECT, PACKAGE, projectType); assertEquals(resultPath, result); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override protected ProjectDiagram constructContent(final Path path, final Overview overview) { ProjectDiagram diagram = getDiagramByPath(path); if (null != diagram) { resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return diagram; } LOG.error("Failed to construct diagram content for path [" + path + "]."); return null; } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testConstructContent() { Overview overview = mock(Overview.class); when(diagramServiceController.getDiagramByPath(path)).thenReturn(diagram); ProjectDiagram result = diagramService.constructContent(path, overview); verify(diagramServiceController, times(1)).getDiagramByPath(path); verify(resourceOpenedEvent, times(1)).fire(eventArgumentCaptor.capture()); assertEquals(sessionInfo, eventArgumentCaptor.getValue().getSessionInfo()); assertEquals(path, eventArgumentCaptor.getValue().getPath()); assertEquals(result, diagram); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public Path save(final Path path, final ProjectDiagram content, final Metadata metadata, final String comment) { LOG.debug("Saving diagram with UUID [" + content.getName() + "] into path [" + path + "]."); return controller.save(path, content, metadataService.setUpAttributes(path, metadata), commentedOptionFactory.makeCommentedOption(comment)); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testSave() { Metadata metadata = mock(Metadata.class); String comment = "COMMENT"; Map<String, Object> attributes = Collections.singletonMap("key", "value"); CommentedOption options = mock(CommentedOption.class); when(metadataService.setUpAttributes(path, metadata)).thenReturn(attributes); when(commentedOptionFactory.makeCommentedOption(comment)).thenReturn(options); when(diagramServiceController.save(path, diagram, attributes, options)).thenReturn(resultPath); Path result = diagramService.save(path, diagram, metadata, comment); verify(diagramServiceController, times(1)).save(path, diagram, attributes, options); assertEquals(resultPath, result); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public Path saveAsXml(final Path path, final String xml, final Metadata metadata, final String comment) { LOG.debug("Saving diagram as XML into path [" + path + "]."); return controller.saveAsXml(path, xml, metadataService.setUpAttributes(path, metadata), commentedOptionFactory.makeCommentedOption(comment)); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testSaveAsXml() { final String xml = "xml"; final String comment = "comment"; final Map<String, Object> attributes = Collections.singletonMap("key", "value"); final Path path = mock(Path.class); final Metadata metadata = mock(Metadata.class); final CommentedOption options = mock(CommentedOption.class); when(metadataService.setUpAttributes(path, metadata)).thenReturn(attributes); when(commentedOptionFactory.makeCommentedOption(comment)).thenReturn(options); diagramService.saveAsXml(path, xml, metadata, comment); verify(diagramServiceController, times(1)).saveAsXml(eq(path), eq(xml), eq(attributes), eq(options)); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public ProjectMetadata saveOrUpdate(final ProjectDiagram diagram) { return controller.saveOrUpdate(diagram); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testSaveOrUpdate() { ProjectMetadata projectMetadata = mock(ProjectMetadata.class); when(diagramServiceController.saveOrUpdate(diagram)).thenReturn(projectMetadata); ProjectMetadata result = diagramService.saveOrUpdate(diagram); verify(diagramServiceController, times(1)).saveOrUpdate(diagram); assertEquals(projectMetadata, result); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public boolean delete(final ProjectDiagram diagram) { return controller.delete(diagram); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testDelete() { when(diagramServiceController.delete(diagram)).thenReturn(true); boolean result = diagramService.delete(diagram); verify(diagramServiceController, times(1)).delete(diagram); assertTrue(result); }
@Test public void testDeleteByPath() { String comment = "COMMENT"; diagramService.delete(path, comment); verify(diagramServiceController, times(1)).delete(path, comment); } |
### Question:
ProjectDiagramServiceImpl extends KieService<ProjectDiagram> implements ProjectDiagramService { @Override public String getRawContent(final ProjectDiagram diagram) { return controller.getRawContent(diagram); } protected ProjectDiagramServiceImpl(); @Inject ProjectDiagramServiceImpl(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final @Named("ioStrategy") IOService ioService,
final SessionInfo sessionInfo,
final Event<ResourceOpenedEvent> resourceOpenedEvent,
final CommentedOptionFactory commentedOptionFactory,
final KieModuleService moduleService,
final KieServiceOverviewLoader overviewLoader,
final User identity); @PostConstruct void init(); @Override ProjectDiagram getDiagramByPath(final Path path); @Override boolean accepts(final Path path); @Override Path create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType); @Override Path create(final Path path,
final String name,
final String defSetId); @Override Path save(final Path path,
final ProjectDiagram content,
final Metadata metadata,
final String comment); @Override Path saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment); @Override ProjectMetadata saveOrUpdate(final ProjectDiagram diagram); @Override Path saveOrUpdateSvg(final Path diagramPath,
final String rawDiagramSvg); @Override boolean delete(final ProjectDiagram diagram); @Override void delete(final Path path,
final String comment); @Override String getRawContent(final ProjectDiagram diagram); }### Answer:
@Test public void testGetRawContent() { when(diagramServiceController.getRawContent(diagram)).thenReturn(RAW_CONTENT); String result = diagramService.getRawContent(diagram); assertEquals(RAW_CONTENT, result); } |
### Question:
ProjectValidationServiceImpl implements ProjectValidationService { @Override public Collection<DiagramElementViolation<RuleViolation>> validate(Diagram diagram) { return domainViolations(diagram).stream() .filter(v -> Objects.nonNull(v.getUUID())) .filter(v -> !"null".equals(v.getUUID())) .map(v -> new ElementViolationImpl.Builder().setUuid(v.getUUID()).setDomainViolations(Collections.singletonList(v)).build()) .collect(Collectors.toList()); } protected ProjectValidationServiceImpl(); @Inject ProjectValidationServiceImpl(Instance<DomainValidator> validators); @Override Collection<DiagramElementViolation<RuleViolation>> validate(Diagram diagram); }### Answer:
@Test public void validate() { final Collection<DiagramElementViolation<RuleViolation>> violations = validationService.validate(diagram); verify(diagram).getMetadata(); verify(metadata).getDefinitionSetId(); assertEquals(violations.size(), 4); final List<DiagramElementViolation<RuleViolation>> ordered = new ArrayList<>(violations); assertEquals(ordered.get(0).getUUID(), UUID_0); assertEquals(ordered.get(0).getDomainViolations().size(), 1); assertEquals(ordered.get(0).getDomainViolations().iterator().next(), domainViolation); assertEquals(ordered.get(1).getUUID(), UUID_1); assertEquals(ordered.get(1).getDomainViolations().size(), 1); assertEquals(ordered.get(1).getDomainViolations().iterator().next(), domainViolation2); assertEquals(ordered.get(2).getUUID(), UUID_1); assertEquals(ordered.get(2).getDomainViolations().size(), 1); assertEquals(ordered.get(2).getDomainViolations().iterator().next(), domainViolation3); assertEquals(ordered.get(3).getUUID(), UUID_1); assertEquals(ordered.get(3).getDomainViolations().size(), 1); assertEquals(ordered.get(3).getDomainViolations().iterator().next(), domainViolation4); } |
### Question:
ProjectClientDiagramValidator extends ClientDiagramValidator { @Override public void validate(Diagram diagram, Consumer<Collection<DiagramElementViolation<RuleViolation>>> resultConsumer) { super.validate(diagram, diagramElementViolations -> { final List<DiagramElementViolation<RuleViolation>> violations = (Objects.nonNull(diagramElementViolations) ? new LinkedList<>(diagramElementViolations) : new LinkedList<>()); backendValidation(diagram, backendViolations -> { violations.addAll(backendViolations); resultConsumer.accept(violations); }); }); } protected ProjectClientDiagramValidator(); @Inject ProjectClientDiagramValidator(final DefinitionManager definitionManager,
final RuleManager ruleManager,
final TreeWalkTraverseProcessor treeWalkTraverseProcessor,
final ModelValidator modelValidator,
final Caller<ProjectValidationService> validationService,
final ManagedInstance<DomainValidator> validators); @Override void validate(Diagram diagram, Consumer<Collection<DiagramElementViolation<RuleViolation>>> resultConsumer); }### Answer:
@Test public void validate() { when(diagram.getGraph()).thenReturn(graphTestHandler.graph); clientDiagramValidator.validate(diagram, result -> assertTrue(result.stream().anyMatch(v -> Objects.equals(backendViolation, v)))); verify(validationService).validate(diagram); } |
### Question:
ProjectMessagesListener { void fireNotification(final AbstractNotification notification) { final SystemMessage systemMessage = new SystemMessage(); final ArrayList<SystemMessage> messagesList = new ArrayList<>(); switch (notification.getType()) { case ERROR: systemMessage.setLevel(Level.ERROR); break; case WARNING: systemMessage.setLevel(Level.WARNING); break; case INFO: systemMessage.setLevel(Level.INFO); break; } final Path path = getDiagramPath(); systemMessage.setText(notification.getMessage()); systemMessage.setPath(path); systemMessage.setMessageType(getMessageType(path)); messagesList.add(systemMessage); PublishMessagesEvent messages = new PublishMessagesEvent(); messages.setShowSystemConsole(false); messages.setMessagesToPublish(messagesList); publishMessagesEvent.fire(messages); } protected ProjectMessagesListener(); @Inject ProjectMessagesListener(final NotificationsObserver notificationsObserver,
final Event<PublishMessagesEvent> publishMessagesEvent,
final Event<UnpublishMessagesEvent> unpublishMessagesEvent,
final SessionManager clientSessionManager); void enable(); static final String MESSAGE_TYPE; }### Answer:
@Test public void testFireNotificationError() { NotificationContext context = buildNotificationContext(); Command<?, CanvasViolation> source = mock(Command.class); CommandNotification commandNotification = CommandNotification.Builder.build( context, source, Notification.Type.ERROR, "message"); projectMessagesListener.fireNotification(commandNotification); ArgumentCaptor<PublishMessagesEvent> eventCaptor = ArgumentCaptor.forClass(PublishMessagesEvent.class); verify(publishMessagesEvent, times(1)).fire(eventCaptor.capture()); testMessageToPublish(eventCaptor.getValue(), Level.ERROR); }
@Test public void testFireNotificationInfo() { NotificationContext context = buildNotificationContext(); Command<?, CanvasViolation> source = mock(Command.class); CommandNotification commandNotification = CommandNotification.Builder.build( context, source, Notification.Type.INFO, "message"); projectMessagesListener.fireNotification(commandNotification); ArgumentCaptor<PublishMessagesEvent> eventCaptor = ArgumentCaptor.forClass(PublishMessagesEvent.class); verify(publishMessagesEvent, times(1)).fire(eventCaptor.capture()); testMessageToPublish(eventCaptor.getValue(), Level.INFO); }
@Test public void testFireNotificationWarning() { NotificationContext context = buildNotificationContext(); Command<?, CanvasViolation> source = mock(Command.class); CommandNotification commandNotification = CommandNotification.Builder.build( context, source, Notification.Type.WARNING, "message"); projectMessagesListener.fireNotification(commandNotification); ArgumentCaptor<PublishMessagesEvent> eventCaptor = ArgumentCaptor.forClass(PublishMessagesEvent.class); verify(publishMessagesEvent, times(1)).fire(eventCaptor.capture()); testMessageToPublish(eventCaptor.getValue(), Level.WARNING); } |
### Question:
ProjectMessagesListener { protected void clearMessages(AbstractNotification notification) { final UnpublishMessagesEvent unpublishMessagesEvent = new UnpublishMessagesEvent(); unpublishMessagesEvent.setMessageType(getMessageType(getDiagramPath())); unpublishMessagesEvent.setShowSystemConsole(false); this.unpublishMessagesEvent.fire(unpublishMessagesEvent); } protected ProjectMessagesListener(); @Inject ProjectMessagesListener(final NotificationsObserver notificationsObserver,
final Event<PublishMessagesEvent> publishMessagesEvent,
final Event<UnpublishMessagesEvent> unpublishMessagesEvent,
final SessionManager clientSessionManager); void enable(); static final String MESSAGE_TYPE; }### Answer:
@Test public void testClearMessages() { final ArgumentCaptor<UnpublishMessagesEvent> eventCaptor = ArgumentCaptor.forClass(UnpublishMessagesEvent.class); projectMessagesListener.clearMessages(mock(AbstractNotification.class)); verify(unpublishMessagesEvent).fire(eventCaptor.capture()); assertEquals(eventCaptor.getValue().getMessageType(), ProjectMessagesListener.MESSAGE_TYPE + PATH); assertEquals(eventCaptor.getValue().isShowSystemConsole(), false); } |
### Question:
ProjectMessagesListener { public void enable() { notificationsObserver.onCommandExecutionFailed(parameter -> fireNotification(parameter)); notificationsObserver.onValidationFailed(parameter -> fireNotification(parameter)); notificationsObserver.onValidationExecuted(parameter -> clearMessages(parameter)); } protected ProjectMessagesListener(); @Inject ProjectMessagesListener(final NotificationsObserver notificationsObserver,
final Event<PublishMessagesEvent> publishMessagesEvent,
final Event<UnpublishMessagesEvent> unpublishMessagesEvent,
final SessionManager clientSessionManager); void enable(); static final String MESSAGE_TYPE; }### Answer:
@Test public void testEnable() { projectMessagesListener.enable(); final ArgumentCaptor<ParameterizedCommand> callbackCaptor = ArgumentCaptor.forClass(ParameterizedCommand.class); verify(notificationsObserver).onCommandExecutionFailed(callbackCaptor.capture()); callbackCaptor.getAllValues().get(0).execute(CommandNotification.Builder.build(buildNotificationContext(), mock(Command.class), Notification.Type.INFO, "message")); verify(projectMessagesListener, times(1)).fireNotification(any()); verify(notificationsObserver).onValidationFailed(callbackCaptor.capture()); final DiagramElementViolation diagramElementViolation = mock(DiagramElementViolation.class); final DomainViolation domainViolation = mock(DomainViolation.class); final ClientTranslationService translationService = mock(ClientTranslationService.class); when(diagramElementViolation.getViolationType()).thenReturn(Violation.Type.ERROR); when(diagramElementViolation.getDomainViolations()).thenReturn(Arrays.asList(domainViolation)); when(domainViolation.getViolationType()).thenReturn(Violation.Type.ERROR); when(translationService.getElementName(anyString())).thenReturn(Optional.of("name")); when(translationService.getValue(anyString(), anyString(), anyString())).thenReturn("message"); when(domainViolation.getMessage()).thenReturn("message"); callbackCaptor.getAllValues().get(1).execute(ValidationFailedNotification.Builder.build(translationService, buildNotificationContext(), Arrays.asList(diagramElementViolation)).get()); verify(projectMessagesListener, times(2)).fireNotification(any()); verify(notificationsObserver).onValidationExecuted(callbackCaptor.capture()); callbackCaptor.getAllValues().get(2).execute(null); verify(projectMessagesListener, times(1)).clearMessages(any()); } |
### Question:
StunnerDocksHandler extends AbstractWorkbenchDocksHandler { public void onDiagramLoseFocusEvent(final @Observes OnDiagramLoseFocusEvent event) { qualifiers = new Annotation[]{DefinitionManager.DEFAULT_QUALIFIER}; refreshDocks(true, true); } StunnerDocksHandler(); @Inject StunnerDocksHandler(final @Any ManagedInstance<StunnerDockSupplier> dockSuppliers); @Override Collection<UberfireDock> provideDocks(final String perspectiveIdentifier); void onDiagramFocusEvent(final @Observes OnDiagramFocusEvent event); void onDiagramLoseFocusEvent(final @Observes OnDiagramLoseFocusEvent event); void onDiagramEditorMaximized(final @Observes ScreenMaximizedEvent event); }### Answer:
@Test public void testOnDiagramLoseFocusEvent() { handler.onDiagramLoseFocusEvent(new OnDiagramLoseFocusEvent()); } |
### Question:
StunnerDocksHandler extends AbstractWorkbenchDocksHandler { public void onDiagramEditorMaximized(final @Observes ScreenMaximizedEvent event) { if (event.isDiagramScreen()) { refreshDocks(true, false); } } StunnerDocksHandler(); @Inject StunnerDocksHandler(final @Any ManagedInstance<StunnerDockSupplier> dockSuppliers); @Override Collection<UberfireDock> provideDocks(final String perspectiveIdentifier); void onDiagramFocusEvent(final @Observes OnDiagramFocusEvent event); void onDiagramLoseFocusEvent(final @Observes OnDiagramLoseFocusEvent event); void onDiagramEditorMaximized(final @Observes ScreenMaximizedEvent event); }### Answer:
@Test public void testOnDiagramEditorMaximized() { handler.onDiagramEditorMaximized(new ScreenMaximizedEvent(true)); assertTrue(handler.shouldRefreshDocks()); assertFalse(handler.shouldDisableDocks()); }
@Test public void testOnOtherEditorMaximized() { handler.onDiagramEditorMaximized(new ScreenMaximizedEvent(false)); assertFalse(handler.shouldRefreshDocks()); assertFalse(handler.shouldDisableDocks()); } |
### Question:
DefaultStunnerDockSupplierImpl implements StunnerDockSupplier { @Override public Collection<UberfireDock> getDocks(String perspectiveIdentifier) { List<UberfireDock> result = new ArrayList<>(); final UberfireDock propertiesDock = new UberfireDock(DOCK_POSITION, PROPERTIES_ICON_TYPE, new DefaultPlaceRequest(PROPERTIES_DOCK_SCREEN_ID), perspectiveIdentifier) .withSize(SIZE) .withLabel(PROPERTIES_LABEL); final UberfireDock explorerDock = new UberfireDock(DOCK_POSITION, EXPLORER_ICON_TYPE, new DefaultPlaceRequest(EXPLORER_DOCK_SCREEN_ID), perspectiveIdentifier) .withSize(SIZE) .withLabel(EXPLORER_LABEL); result.add(propertiesDock); result.add(explorerDock); return result; } @Override Collection<UberfireDock> getDocks(String perspectiveIdentifier); }### Answer:
@Test public void getDocks() { DefaultStunnerDockSupplierImpl defaultStunnerDockSupplier = new DefaultStunnerDockSupplierImpl(); Collection<UberfireDock> docks = defaultStunnerDockSupplier.getDocks(PERSPECTIVE_IDENTIFIER); assertEquals(2, docks.size(), 0); Optional<UberfireDock> propertiesDock = docks.stream() .filter(dock -> dock.getPlaceRequest().getIdentifier().compareTo(PROPERTIES_DOCK_SCREEN_ID) == 0) .findFirst(); assertDock(propertiesDock.get(), DOCK_POSITION, PROPERTIES_ICON_TYPE, PROPERTIES_DOCK_SCREEN_ID, PERSPECTIVE_IDENTIFIER, SIZE, PROPERTIES_LABEL, null); Optional<UberfireDock> explorerDock = docks.stream() .filter(dock -> dock.getPlaceRequest().getIdentifier().compareTo(DefaultStunnerDockSupplierImpl.EXPLORER_DOCK_SCREEN_ID) == 0) .findFirst(); assertDock(explorerDock.get(), DOCK_POSITION, EXPLORER_ICON_TYPE, EXPLORER_DOCK_SCREEN_ID, PERSPECTIVE_IDENTIFIER, SIZE, EXPLORER_LABEL, null); } |
### Question:
ClientProjectDiagramService extends ClientDiagramServiceImpl<ProjectMetadata, ProjectDiagram, ProjectDiagramService> { public void create(final Path path, final String name, final String defSetId, final String projectName, final Package projectPkg, final Optional<String> projectType, final ServiceCallback<Path> callback) { diagramServiceCaller.call((RemoteCallback<Path>) callback::onSuccess, (message, throwable) -> { callback.onError(createOnErrorHandler(throwable, name, projectPkg)); return false; }).create(path, name, defSetId, projectName, projectPkg, projectType); } protected ClientProjectDiagramService(); @Inject ClientProjectDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<ProjectDiagramService> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); void create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType,
final ServiceCallback<Path> callback); void saveOrUpdate(final Path path,
final ProjectDiagram diagram,
final Metadata metadata,
final String comment,
final ServiceCallback<ProjectDiagram> callback); void saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment,
final ServiceCallback<String> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testCreateWithProjectDetails() { final String name = "d1"; final String defSetId = "id1"; final String projName = "project-name"; final Package projPackage = mock(Package.class); final ServiceCallback<Path> callback = mock(ServiceCallback.class); final Optional<String> projectType = Optional.of("type"); tested.create(path, name, defSetId, projName, projPackage, projectType, callback); verify(diagramService, times(1)).create(eq(path), eq(name), eq(defSetId), eq(projName), eq(projPackage), eq(projectType)); verify(callback, times(1)).onSuccess(any(Path.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
@Test public void testDuplicatedBusinessProcess() { final String name = "d1"; final String defSetId = "id1"; final String projName = "project-name"; final Package projPackage = new Package(); final Optional<String> projectType = Optional.of("type"); ProjectDiagramService projectDiagramService = mock(ProjectDiagramService.class); doThrow(new FileAlreadyExistsException(path.toString())).when(projectDiagramService).create(path, name, defSetId, projName, projPackage, projectType); exception.expect(FileAlreadyExistsException.class); projectDiagramService.create(path, name, defSetId, projName, projPackage, projectType); } |
### Question:
ClientProjectDiagramService extends ClientDiagramServiceImpl<ProjectMetadata, ProjectDiagram, ProjectDiagramService> { public void saveAsXml(final Path path, final String xml, final Metadata metadata, final String comment, final ServiceCallback<String> callback) { diagramServiceCaller.call(v -> callback.onSuccess(xml), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveAsXml(path, xml, metadata, comment); } protected ClientProjectDiagramService(); @Inject ClientProjectDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<ProjectDiagramService> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); void create(final Path path,
final String name,
final String defSetId,
final String projectName,
final Package projectPkg,
final Optional<String> projectType,
final ServiceCallback<Path> callback); void saveOrUpdate(final Path path,
final ProjectDiagram diagram,
final Metadata metadata,
final String comment,
final ServiceCallback<ProjectDiagram> callback); void saveAsXml(final Path path,
final String xml,
final Metadata metadata,
final String comment,
final ServiceCallback<String> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSaveAsXml() { final String xml = "xml"; final String comment = "comment"; final Metadata metadata = mock(Metadata.class); final ServiceCallback<String> callback = mock(ServiceCallback.class); tested.saveAsXml(path, xml, metadata, comment, callback); verify(diagramService, times(1)).saveAsXml(eq(path), eq(xml), eq(metadata), eq(comment)); verify(callback, times(1)).onSuccess(anyString()); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { protected String formatTitle(final String title) { if (Objects.isNull(resourceType)) { return title; } return TITLE_FORMAT_TEMPLATE .replace("#title", title) .replace("#suffix", resourceType.getSuffix()) .replace("#type", resourceType.getShortName()); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testFormatTitle() { String title = "testDiagram"; String formattedTitle = presenter.formatTitle(title); assertEquals(formattedTitle, "testDiagram." + resourceType.getSuffix() + " - " + resourceType.getShortName()); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override public void open(final ProjectDiagram diagram, final Viewer.Callback callback) { editor.open(diagram, callback); SaveAndRenameCommandBuilder saveAndRenameCommandBuilder = getSaveAndRenameCommandBuilder(); saveAndRenameCommandBuilder.addContentSupplier(editor.getEditorProxy().getContentSupplier()); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testOpen() { Overview overview = open(); verify(view).showLoading(); verify(view).setWidget(eq(sessionPresenterView)); verify(sessionEditorPresenter).withToolbar(eq(false)); verify(sessionEditorPresenter).withPalette(eq(true)); verify(sessionEditorPresenter).open(eq(diagram), any(SessionPresenter.SessionPresenterCallback.class)); assertEquals(diagram.hashCode(), presenter.getCurrentDiagramHash()); verify(view).hideBusyIndicator(); verify(overviewWidget).setContent(eq(overview), eq(filePath)); verify(kieView).clear(); verify(kieView).addMainEditorPage(eq(view)); verify(kieView).addOverviewPage(eq(overviewWidget), any(com.google.gwt.user.client.Command.class)); verify(saveAndRenameCommandBuilderMock).addContentSupplier(any()); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override public void onSaveError(final ClientRuntimeError error) { editor.onSaveError(error); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testStunnerSave_SaveFailed() { final String errorMessage = "Something went wrong"; final ClientRuntimeError cre = new ClientRuntimeError(errorMessage); final Overview overview = assertBasicStunnerSaveOperation(true); final ServiceCallback<ProjectDiagram> serviceCallback = assertSaveOperation(overview); serviceCallback.onError(cre); verify(presenterCore).onSaveError(eq(cre)); final ArgumentCaptor<Consumer> consumerCaptor = ArgumentCaptor.forClass(Consumer.class); verify(diagramClientErrorHandler).handleError(eq(cre), consumerCaptor.capture()); final Consumer consumer = consumerCaptor.getValue(); consumer.accept(errorMessage); verify(errorPopupPresenter).showMessage(eq(errorMessage)); }
@Test @SuppressWarnings("unchecked") public void testXMLSave_SaveFailed() { final String xml = "xml"; final String errorMessage = "Something went wrong"; final ClientRuntimeError cre = new ClientRuntimeError(errorMessage); final ServiceCallback<String> serviceCallback = assertBasicXMLSaveOperation(xml); serviceCallback.onError(cre); verify(presenterCore).onSaveError(eq(cre)); final ArgumentCaptor<Consumer> consumerCaptor = ArgumentCaptor.forClass(Consumer.class); verify(diagramClientErrorHandler).handleError(eq(cre), consumerCaptor.capture()); final Consumer consumer = consumerCaptor.getValue(); consumer.accept(errorMessage); verify(errorPopupPresenter).showMessage(eq(errorMessage)); } |
### Question:
GridCellTuple implements RequiresResize { @Override public void onResize() { final GridColumn<?> parentColumn = gridWidget.getModel().getColumns().get(columnIndex); parentColumn.setWidth(parentColumn.getWidth()); } GridCellTuple(final int rowIndex,
final int columnIndex,
final GridWidget gridWidget); int getRowIndex(); void setRowIndex(final int rowIndex); int getColumnIndex(); void setColumnIndex(final int columnIndex); GridWidget getGridWidget(); void proposeContainingColumnWidth(final double proposedWidth,
final Function<BaseExpressionGrid, Double> requiredWidthSupplier); @Override void onResize(); }### Answer:
@Test public void testOnResizeSetsColumnWidth() { when(gridColumn.getWidth()).thenReturn(100.0); tuple.onResize(); verify(gridColumn).setWidth(100.0); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override protected Caller<? extends SupportsSaveAndRename<ProjectDiagramResource, org.guvnor.common.services.shared.metadata.model.Metadata>> getSaveAndRenameServiceCaller() { return projectDiagramResourceServiceCaller; } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testGetSaveAndRenameServiceCaller() { final Caller<ProjectDiagramResourceService> expectedCaller = this.projectDiagramResourceServiceCaller; final Caller<? extends SupportsSaveAndRename<ProjectDiagramResource, Metadata>> actualCaller = presenter.getSaveAndRenameServiceCaller(); assertEquals(expectedCaller, actualCaller); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override protected Integer getCurrentContentHash() { return editor.getCurrentDiagramHash(); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testGetCurrentContentHash() { final Integer expectedContentHash = 42; doReturn(expectedContentHash).when(presenterCore).getCurrentDiagramHash(); final Integer actualContentHash = presenter.getCurrentContentHash(); assertEquals(expectedContentHash, actualContentHash); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override public int getCurrentDiagramHash() { return editor.getCurrentDiagramHash(); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testDiagramHashCodeWithInvalidFile() { final String xml = "xml"; when(xmlEditorView.getContent()).thenReturn(xml); openInvalidFile(xml); assertEquals(xml.hashCode(), presenter.getCurrentDiagramHash()); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override public void hideDocks() { super.hideDocks(); onDiagramLostFocusEvent.fire(new OnDiagramLoseFocusEvent()); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testHideDocks() { presenter.hideDocks(); verify(onDiagramLostFocusEvent).fire(any()); verify(defaultEditorDock).hide(); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override public void showDocks() { onDiagramFocusEvent.fire(new OnDiagramFocusEvent(getDockQualifiers())); super.showDocks(); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testShowDocks() { PerspectiveActivity perspectiveActivity = mock(PerspectiveActivity.class); when(perspectiveActivity.getIdentifier()).thenReturn("perspectiveId"); when(perspectiveManagerMock.getCurrentPerspective()).thenReturn(perspectiveActivity); presenter.showDocks(); verify(onDiagramFocusEvent).fire(any()); verify(defaultEditorDock).show(); } |
### Question:
BaseHasDynamicHeightCell extends DMNGridCell<T> implements HasDynamicHeight { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (!(o instanceof BaseHasDynamicHeightCell)) { return false; } if (!super.equals(o)) { return false; } final BaseHasDynamicHeightCell<?> that = (BaseHasDynamicHeightCell<?>) o; return Double.compare(that.lineHeight, lineHeight) == 0 && Double.compare(that.height, height) == 0; } BaseHasDynamicHeightCell(final GridCellValue<T> value,
final double lineHeight); @Override double getHeight(); @Override boolean equals(final Object o); @Override int hashCode(); static final double DEFAULT_HEIGHT; }### Answer:
@Test public void testEquals() { final CELL sameCell = makeCell(); assertThat(cell).isEqualTo(sameCell); assertThat(cell.hashCode()).isEqualTo(sameCell.hashCode()); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @Override public Annotation[] getDockQualifiers() { return new Annotation[]{DefinitionManager.DEFAULT_QUALIFIER}; } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test public void testDocksQualifiers() { final Annotation[] qualifiers = presenter.getDockQualifiers(); assertEquals(1, qualifiers.length); assertEquals(DefinitionManager.DEFAULT_QUALIFIER, qualifiers[0]); } |
### Question:
AbstractProjectDiagramEditor extends KieEditor<ProjectDiagramResource> implements DiagramEditorCore<ProjectMetadata, ProjectDiagram> { @SuppressWarnings("unchecked") public void addDocumentationPage(final ProjectDiagram diagram) { Optional.ofNullable(documentationView.isEnabled()) .filter(Boolean.TRUE::equals) .ifPresent(enabled -> { final String label = translationService.getValue(StunnerProjectClientConstants.DOCUMENTATION); addPage(new DocumentationPage(documentationView.initialize(diagram), label, () -> onDiagramFocusEvent.fire(new OnDiagramFocusEvent(getDockQualifiers())), () -> Objects.equals(2, kieView.getSelectedTabIndex()))); }); } AbstractProjectDiagramEditor(final AbstractProjectDiagramEditor.View view,
final TextEditorView xmlEditorView,
final ManagedInstance<SessionEditorPresenter<EditorSession>> editorSessionPresenterInstances,
final ManagedInstance<SessionViewerPresenter<ViewerSession>> viewerSessionPresenterInstances,
final Event<OnDiagramFocusEvent> onDiagramFocusEvent,
final Event<OnDiagramLoseFocusEvent> onDiagramLostFocusEvent,
final Event<NotificationEvent> notificationEvent,
final ErrorPopupPresenter errorPopupPresenter,
final DiagramClientErrorHandler diagramClientErrorHandler,
final DocumentationView documentationView,
final R resourceType,
final AbstractDiagramEditorMenuSessionItems<?> menuSessionItems,
final ProjectMessagesListener projectMessagesListener,
final ClientTranslationService translationService,
final ClientProjectDiagramService projectDiagramServices,
final Caller<ProjectDiagramResourceService> projectDiagramResourceServiceCaller); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override RemoteCallback<Path> getSaveSuccessCallback(final int newHash); @Override void hideDocks(); @Override void showDocks(); @Override //Override visibility from KieEditor to allow inner class ProjectDiagramEditorCore access abstract String getEditorIdentifier(); @Override String getTitleText(); @Override void open(final ProjectDiagram diagram,
final Viewer.Callback callback); @Override Annotation[] getDockQualifiers(); @Override void initialiseKieEditorForSession(final ProjectDiagram diagram); @SuppressWarnings("unchecked") void addDocumentationPage(final ProjectDiagram diagram); @Override SessionEditorPresenter<EditorSession> newSessionEditorPresenter(); @Override SessionViewerPresenter<ViewerSession> newSessionViewerPresenter(); @Override int getCurrentDiagramHash(); @Override CanvasHandler getCanvasHandler(); @Override void onSaveError(final ClientRuntimeError error); @Override SessionPresenter<? extends ClientSession, ?, Diagram> getSessionPresenter(); @Override void doFocus(); @Override void doLostFocus(); AbstractDiagramEditorMenuSessionItems getMenuSessionItems(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAddDocumentationPage() { when(documentationView.isEnabled()).thenReturn(Boolean.TRUE); when(translationService.getValue(StunnerProjectClientConstants.DOCUMENTATION)).thenReturn(DOC_LABEL); when(documentationView.initialize(diagram)).thenReturn(documentationView); presenter.addDocumentationPage(diagram); verify(translationService).getValue(StunnerProjectClientConstants.DOCUMENTATION); verify(kieView).addPage(documentationPageCaptor.capture()); final DocumentationPage documentationPage = documentationPageCaptor.getValue(); assertEquals(documentationPage.getDocumentationView(), documentationView); assertEquals(documentationPage.getLabel(), DOC_LABEL); } |
### Question:
ProjectDiagramEditorView extends KieEditorViewImpl implements AbstractProjectDiagramEditor.View { @Override public void setWidget(final IsWidget widget) { editorPanel.clear(); editorPanel.add(widget); } protected ProjectDiagramEditorView(); @Inject ProjectDiagramEditorView(final ResizeFlowPanel editorPanel); @Override void init(final DiagramEditorCore presenter); @Override void onResize(); @Override void setWidget(final IsWidget widget); @PreDestroy void destroy(); }### Answer:
@Test public void testSetWidget() { final IsWidget editor = mock(IsWidget.class); tested.setWidget(editor); verify(editorPanel).clear(); verify(editorPanel).add(eq(editor)); } |
### Question:
ProjectDiagramEditorView extends KieEditorViewImpl implements AbstractProjectDiagramEditor.View { @Override public void onResize() { editorPanel.onResize(); } protected ProjectDiagramEditorView(); @Inject ProjectDiagramEditorView(final ResizeFlowPanel editorPanel); @Override void init(final DiagramEditorCore presenter); @Override void onResize(); @Override void setWidget(final IsWidget widget); @PreDestroy void destroy(); }### Answer:
@Test public void testOnResize() { tested.onResize(); verify(editorPanel).onResize(); } |
### Question:
ProjectDiagramEditorView extends KieEditorViewImpl implements AbstractProjectDiagramEditor.View { @Override protected void onAttach() { super.onAttach(); if (getElement().getParentElement() != null) { getElement().getParentElement().getStyle().setHeight(100, Style.Unit.PCT); getElement().getParentElement().getStyle().setWidth(100, Style.Unit.PCT); getElement().getParentElement().getStyle().setDisplay(Style.Display.TABLE); } } protected ProjectDiagramEditorView(); @Inject ProjectDiagramEditorView(final ResizeFlowPanel editorPanel); @Override void init(final DiagramEditorCore presenter); @Override void onResize(); @Override void setWidget(final IsWidget widget); @PreDestroy void destroy(); }### Answer:
@Test public void testOnAttach() { testOnAttach(true); testOnAttach(false); } |
### Question:
StunnerProjectPreferencesRegistryLoader extends StunnerPreferencesRegistryLoader { @Override public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { super.load(metadata, preferences -> profilePreferencesLoader.load(metadata, profile -> { metadata.setProfileId(profile.getProfileId()); loadCompleteCallback.execute(preferences); }, errorCallback), errorCallback); } @Inject StunnerProjectPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences,
final StunnerProfilePreferencesLoader profilePreferencesLoader); @Override void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testLoad() { final ParameterizedCommand<StunnerPreferences> loadCompleteCallback = mock(ParameterizedCommand.class); final ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); final StunnerPreferences pre = mock(StunnerPreferences.class); doAnswer(invocation -> { ((ParameterizedCommand<StunnerPreferences>) invocation.getArguments()[0]).execute(pre); return null; }).when(preferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); tested.load(metadata, loadCompleteCallback, errorCallback); assertEquals(PROFILE_ID, metadata.getProfileId()); verify(preferencesHolders, times(1)).select(eq(qualifier)); verify(loadCompleteCallback, times(1)).execute(eq(pre)); verify(errorCallback, never()).execute(any(Throwable.class)); verify(preferencesHolder, times(1)).set(eq(pre), eq(StunnerPreferences.class)); verify(preferencesHolder, times(1)).set(eq(textPreferences), eq(StunnerTextPreferences.class)); } |
### Question:
StunnerProfilePreferencesLoader { public void load(final Metadata metadata, final ParameterizedCommand<Profile> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { profilePreferences .load(profilePreferences -> { final String profileName = profilePreferences.getProfile().getName(); loadCompleteCallback.execute(getProfileByPreference(metadata, profileName) .orElse(defaultProfile)); }, errorCallback); } @Inject StunnerProfilePreferencesLoader(final ProfileManager profileManager,
final ProfilePreferences profilePreferences,
final FullProfile defaultProfile); void load(final Metadata metadata,
final ParameterizedCommand<Profile> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testLoad() { ParameterizedCommand<Profile> loadCallback = mock(ParameterizedCommand.class); ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); tested.load(metadata, loadCallback, errorCallback); verify(errorCallback, never()).execute(any(Throwable.class)); verify(loadCallback, times(1)).execute(eq(profile)); }
@Test @SuppressWarnings("unchecked") public void testLoadDefaultProfile() { when(profile.getProjectProfileName()).thenReturn(org.kie.workbench.common.profile.api.preferences.Profile.FULL.getName()); ParameterizedCommand<Profile> loadCallback = mock(ParameterizedCommand.class); ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); tested.load(metadata, loadCallback, errorCallback); verify(errorCallback, never()).execute(any(Throwable.class)); verify(loadCallback, times(1)).execute(eq(DEFAULT_PROFILE)); }
@Test @SuppressWarnings("unchecked") public void testError() { final Throwable exception = mock(Throwable.class); doAnswer(invocation -> { ParameterizedCommand<Throwable> callback = (ParameterizedCommand<Throwable>) invocation.getArguments()[1]; callback.execute(exception); return null; }).when(profilePreferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); ParameterizedCommand<Profile> loadCallback = mock(ParameterizedCommand.class); ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); tested.load(metadata, loadCallback, errorCallback); verify(errorCallback, times(1)).execute(eq(exception)); verify(loadCallback, never()).execute(any(Profile.class)); } |
### Question:
AbstractDragProxy { MouseMoveHandler getMouseMoveHandler(final int initialX, final int initialY, final int timeout, final Callback callback) { return mouseMoveEvent -> { if (isAttached()) { if (xDiff() == null) { xDiff = initialX - mouseMoveEvent.getX(); } if (yDiff() == null) { yDiff = initialY - mouseMoveEvent.getY(); } final int x = relativeX(getXDiff() + mouseMoveEvent.getX()); final int y = relativeY(getYDiff() + mouseMoveEvent.getY()); setLocation(shapeProxy, x, y); scheduleMove(callback, x, y, timeout); } }; } AbstractDragProxy(final Layer layer,
final T shape,
final int x,
final int y,
final int timeout,
final Callback callback); void clear(); void destroy(); }### Answer:
@Test public void testGetMouseMoveHandler() { final int initialX = 100; final int initialY = 100; final int expectedX = 175; final int expectedY = 175; final MouseMoveHandler handler = abstractDragProxy.getMouseMoveHandler(initialX, initialY, timeout, callback); when(mouseMoveEvent.getX()).thenReturn(150); when(mouseMoveEvent.getY()).thenReturn(150); doReturn(0).when(abstractDragProxy).xDiff(); doReturn(0).when(abstractDragProxy).yDiff(); doReturn(25).when(abstractDragProxy).getXDiff(); doReturn(25).when(abstractDragProxy).getYDiff(); doReturn(true).when(abstractDragProxy).isAttached(); handler.onMouseMove(mouseMoveEvent); verify(abstractDragProxy).setLocation(shapeProxy, expectedX, expectedY); verify(abstractDragProxy).scheduleMove(callback, expectedX, expectedY, timeout); verify(layer, never()).batch(); } |
### Question:
BaseHasDynamicHeightCell extends DMNGridCell<T> implements HasDynamicHeight { @Override public int hashCode() { return Objects.hash(super.hashCode(), lineHeight, height); } BaseHasDynamicHeightCell(final GridCellValue<T> value,
final double lineHeight); @Override double getHeight(); @Override boolean equals(final Object o); @Override int hashCode(); static final double DEFAULT_HEIGHT; }### Answer:
@Test public void testEqualsIdentity() { assertThat(cell).isEqualTo(cell); assertThat(cell.hashCode()).isEqualTo(cell.hashCode()); }
@Test public void testEqualsDifferentLineHeight() { final CELL differentCell = makeCell(LINE_HEIGHT + 1); assertThat(cell).isNotEqualTo(differentCell); assertThat(cell.hashCode()).isNotEqualTo(differentCell.hashCode()); } |
### Question:
AbstractDragProxy { MouseUpHandler getMouseUpHandler(final Callback callback) { return mouseUpEvent -> { if (isAttached()) { timer.cancel(); final int x = relativeX(getXDiff() + mouseUpEvent.getX()); final int y = relativeY(getYDiff() + mouseUpEvent.getY()); clear(); callback.onComplete(x, y); } }; } AbstractDragProxy(final Layer layer,
final T shape,
final int x,
final int y,
final int timeout,
final Callback callback); void clear(); void destroy(); }### Answer:
@Test public void testGetMouseUpHandler() { final MouseUpHandler handler = abstractDragProxy.getMouseUpHandler(callback); final int expectedX = 175; final int expectedY = 175; when(mouseUpEvent.getX()).thenReturn(150); when(mouseUpEvent.getY()).thenReturn(150); doReturn(25).when(abstractDragProxy).getXDiff(); doReturn(25).when(abstractDragProxy).getYDiff(); doNothing().when(abstractDragProxy).clear(); doReturn(true).when(abstractDragProxy).isAttached(); handler.onMouseUp(mouseUpEvent); verify(abstractDragProxy).clear(); verify(callback).onComplete(expectedX, expectedY); } |
### Question:
AbstractDragProxy { int relativeX(final int x) { final Double relativeX = ((x) - getViewportTransform().getTranslateX()) / getViewportTransform().getScaleX(); return relativeX.intValue(); } AbstractDragProxy(final Layer layer,
final T shape,
final int x,
final int y,
final int timeout,
final Callback callback); void clear(); void destroy(); }### Answer:
@Test public void testRelativeX() { final double transformTranslateX = 50d; final double transformScaleX = 1.5d; final int x = 100; final int expectedRelativeX = 33; when(transform.getTranslateX()).thenReturn(transformTranslateX); when(transform.getScaleX()).thenReturn(transformScaleX); final int actualRelativeX = abstractDragProxy.relativeX(x); assertEquals(expectedRelativeX, actualRelativeX); } |
### Question:
AbstractDragProxy { int relativeY(final int y) { final Double relativeY = ((y) - getViewportTransform().getTranslateY()) / getViewportTransform().getScaleY(); return relativeY.intValue(); } AbstractDragProxy(final Layer layer,
final T shape,
final int x,
final int y,
final int timeout,
final Callback callback); void clear(); void destroy(); }### Answer:
@Test public void testRelativeY() { final double transformTranslateY = 50d; final double transformScaleY = 1.5d; final int y = 100; final int expectedRelativeY = 33; when(transform.getTranslateY()).thenReturn(transformTranslateY); when(transform.getScaleY()).thenReturn(transformScaleY); final int actualRelativeY = abstractDragProxy.relativeY(y); assertEquals(expectedRelativeY, actualRelativeY); } |
### Question:
Grid implements Iterable<Grid.Point> { public Point findPosition(final Point anchorPoint, final Direction direction) { int width = getWidth(); int height = getHeight(); int x = anchorPoint.getX(); int y = anchorPoint.getY(); switch (direction) { case NORTH: x -= width / 2; y -= height; break; case SOUTH: x -= width / 2; break; case EAST: y -= height / 2; break; case WEST: x -= width; y -= height / 2; break; case NONE: x -= width / 2; y -= height / 2; break; case NORTH_EAST: y -= height; break; case SOUTH_EAST: break; case SOUTH_WEST: x -= width; break; case NORTH_WEST: x -= width; y -= height; break; default: throw new UnsupportedOperationException(); } return new Point(x, y); } Grid(final int padding,
final int iconSize,
final int rows,
final int cols); Point findPosition(final Point anchorPoint,
final Direction direction); Point findPosition(final int row,
final int col); @Override Iterator<Point> iterator(); int getRows(); int getCols(); int size(); int getWidth(); int getHeight(); }### Answer:
@Test public void testFindSimplePosition() { Point p = grid.findPosition(4, 5); assertEquals(160, p.getX()); assertEquals(130, p.getY()); }
@Test(expected = IllegalArgumentException.class) public void testFindSimplePositionRowIsTooBig() { grid.findPosition(10000, 5); }
@Test(expected = IllegalArgumentException.class) public void testFindSimplePositionColIsTooBig() { grid.findPosition(5, 10000); }
@Test(expected = IllegalArgumentException.class) public void testFindSimplePositionNegativeRow() { grid.findPosition(-1, 5); }
@Test(expected = IllegalArgumentException.class) public void testFindSimplePositionNegativeCol() { grid.findPosition(5, -1); } |
### Question:
Grid implements Iterable<Grid.Point> { public int getWidth() { return calculateDistance(getCols()); } Grid(final int padding,
final int iconSize,
final int rows,
final int cols); Point findPosition(final Point anchorPoint,
final Direction direction); Point findPosition(final int row,
final int col); @Override Iterator<Point> iterator(); int getRows(); int getCols(); int size(); int getWidth(); int getHeight(); }### Answer:
@Test public void testGetWidth() { assertEquals(1210, grid.getWidth()); } |
### Question:
Grid implements Iterable<Grid.Point> { public int getHeight() { return calculateDistance(getRows()); } Grid(final int padding,
final int iconSize,
final int rows,
final int cols); Point findPosition(final Point anchorPoint,
final Direction direction); Point findPosition(final int row,
final int col); @Override Iterator<Point> iterator(); int getRows(); int getCols(); int size(); int getWidth(); int getHeight(); }### Answer:
@Test public void testGetHeight() { assertEquals(910, grid.getHeight()); } |
### Question:
Grid implements Iterable<Grid.Point> { public int size() { return getRows() * getCols(); } Grid(final int padding,
final int iconSize,
final int rows,
final int cols); Point findPosition(final Point anchorPoint,
final Direction direction); Point findPosition(final int row,
final int col); @Override Iterator<Point> iterator(); int getRows(); int getCols(); int size(); int getWidth(); int getHeight(); }### Answer:
@Test public void testSize() { assertEquals(1200, grid.size()); } |
### Question:
Grid implements Iterable<Grid.Point> { @Override public Iterator<Point> iterator() { return new GridIterator(this); } Grid(final int padding,
final int iconSize,
final int rows,
final int cols); Point findPosition(final Point anchorPoint,
final Direction direction); Point findPosition(final int row,
final int col); @Override Iterator<Point> iterator(); int getRows(); int getCols(); int size(); int getWidth(); int getHeight(); }### Answer:
@Test public void testIterator() { Iterator iterator = grid.iterator(); int cellCount = 0; while (iterator.hasNext()) { iterator.next(); cellCount++; } assertEquals(grid.size(), cellCount); }
@Test(expected = NoSuchElementException.class) public void testIteratorOverflow() { Iterator iterator = grid.iterator(); while (iterator.hasNext()) { iterator.next(); } iterator.next(); }
@Test(expected = UnsupportedOperationException.class) public void testIteratorRemoveNotSupported() { grid.iterator().remove(); } |
### Question:
Decorator extends Group { public IPrimitive<?> build(final IPrimitive<?> item, final double width, final double height) { decorator = createRectangle(width, height); this.add(decorator); this.add(item); decorator.setX(item.getX() - (padding / 4)); decorator.setY(item.getY() - (padding / 4)); decorator.addNodeMouseEnterHandler(nodeMouseEnterEvent -> show(nodeMouseEnterEvent.getMouseEvent().getClientX(), nodeMouseEnterEvent.getMouseEvent().getClientY())); decorator.addNodeMouseExitHandler(nodeMouseExitEvent -> hide()); decorator.addNodeMouseMoveHandler(nodeMouseMoveEvent -> timer.cancel()); item.setDraggable(false); decorator.setDraggable(false).moveToTop(); return this; } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testBuild() { decorator.build(primitive, 5.0, 8.0); verify(decorator).createRectangle(5.0, 8.0); verify(decorator).add(primitive); verify(decorator).add(rectangle); verify(rectangle).addNodeMouseEnterHandler(anyObject()); verify(rectangle).addNodeMouseExitHandler(anyObject()); verify(rectangle).addNodeMouseMoveHandler(anyObject()); verify(rectangle).setDraggable(false); verify(rectangle).moveToTop(); } |
### Question:
Decorator extends Group { protected void fireHide() { if (null != callback) { callback.onHide(); } } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testFireHide() { decorator.fireHide(); verify(callback).onHide(); } |
### Question:
Decorator extends Group { protected void fireShow(final double x, final double y) { if (null != callback) { callback.onShow(x, y); } } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testFireShow() { decorator.fireShow(3.0, 5.0); verify(callback).onShow(3.0, 5.0); } |
### Question:
Decorator extends Group { public Decorator hide() { if (!timer.isRunning()) { decorator.animate(AnimationTweener.LINEAR, AnimationProperties.toPropertyList(AnimationProperty.Properties.STROKE_ALPHA(0)), ANIMATION_DURATION, createHideAnimationCallback()); } return this; } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testHide() { decorator.build(primitive, 6.0, 0.6); doReturn(animationHandle).when((Node) rectangle).animate(anyObject(), anyObject(), anyDouble(), anyObject()); decorator.resetTimer(timer); when(timer.isRunning()).thenReturn(true); decorator.hide(); verify(rectangle, never()).animate(anyObject(), anyObject(), anyDouble(), anyObject()); when(timer.isRunning()).thenReturn(false); decorator.hide(); verify(decorator).createHideAnimationCallback(); verify(rectangle).animate(anyObject(), anyObject(), anyDouble(), anyObject()); } |
### Question:
Decorator extends Group { protected AnimationCallback createHideAnimationCallback() { return new AnimationCallback() { @Override public void onClose(IAnimation animation, IAnimationHandle handle) { super.onClose(animation, handle); fireHide(); } }; } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testCreateHideAnimationCallback() { decorator.createHideAnimationCallback().onClose(animation, animationHandle); verify(decorator).fireHide(); } |
### Question:
Decorator extends Group { public Decorator show(final double x, final double y) { if (!timer.isRunning()) { decorator.animate(AnimationTweener.LINEAR, AnimationProperties.toPropertyList(AnimationProperty.Properties.STROKE_ALPHA(1)), ANIMATION_DURATION, createShowAnimationCallback(x, y)); timer.schedule(TIMER_DELAY); } return this; } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testShow() { decorator.build(primitive, 6.0, 0.6); doReturn(animationHandle).when((Node) rectangle).animate(anyObject(), anyObject(), anyDouble(), anyObject()); decorator.resetTimer(timer); when(timer.isRunning()).thenReturn(true); decorator.show(4, 5); verify(rectangle, never()).animate(anyObject(), anyObject(), anyDouble(), anyObject()); when(timer.isRunning()).thenReturn(false); decorator.show(0.1, 0); verify(decorator).createShowAnimationCallback(0.1, 0); verify(rectangle).animate(anyObject(), anyObject(), anyDouble(), anyObject()); verify(timer).schedule(anyInt()); } |
### Question:
LiteralExpressionGridRow extends BaseGridRow { @Override public double getHeight() { double height = DEFAULT_HEIGHT; for (GridCell<?> cell : this.getCells().values()) { if (cell instanceof HasDynamicHeight) { height = Math.max(((HasDynamicHeight) cell).getHeight(), height); } } return height; } LiteralExpressionGridRow(); @Override double getHeight(); }### Answer:
@Test public void testEmptyRow() { final GridRow row = new LiteralExpressionGridRow(); assertThat(row.getHeight()).isEqualTo(DEFAULT_HEIGHT); }
@Test public void testGetHeightWithHasDynamicHeightCell() { final GridRow row = spy(new LiteralExpressionGridRow()); final Map<Integer, GridCell> cells = new HashMap<Integer, GridCell>() {{ put(0, new MockHasDynamicHeightCell<>(new BaseGridCellValue<>("cheese"))); put(1, new BaseGridCell<>(new BaseGridCellValue<>("cheese"))); }}; doReturn(cells).when(row).getCells(); assertThat(row.getHeight()).isEqualTo(CELL_HEIGHT); }
@Test public void testGetHeightWithoutHasDynamicHeightCell() { final GridRow row = spy(new LiteralExpressionGridRow()); final Map<Integer, GridCell> cells = new HashMap<Integer, GridCell>() {{ put(0, new BaseGridCell<>(new BaseGridCellValue<>("cheese"))); }}; doReturn(cells).when(row).getCells(); assertThat(row.getHeight()).isEqualTo(DEFAULT_HEIGHT); } |
### Question:
Decorator extends Group { protected AnimationCallback createShowAnimationCallback(final double x, final double y) { return new AnimationCallback() { @Override public void onClose(final IAnimation animation, final IAnimationHandle handle) { super.onClose(animation, handle); fireShow(x, y); } }; } Decorator(final ItemCallback callback); Decorator setPadding(final double padding); Decorator setItemCallback(final ItemCallback callback); IPrimitive<?> build(final IPrimitive<?> item,
final double width,
final double height); Rectangle createRectangle(final double width,
final double height); Decorator show(final double x,
final double y); Decorator hide(); }### Answer:
@Test public void testCreateShowAnimationCallback() { decorator.createShowAnimationCallback(0.9, 1.1).onClose(animation, animationHandle); verify(decorator).fireShow(0.9, 1.1); } |
### Question:
FormGenerationServiceImpl implements FormGenerationService { @Override public void generateProcessForm(final Diagram diagram) { doGenerate(diagram, () -> formDefinitionGenerator.generateProcessForm(diagram)); } protected FormGenerationServiceImpl(); @Inject FormGenerationServiceImpl(final Event<FormGeneratedEvent> formGeneratedEvent,
final Event<FormGenerationFailureEvent> formGenerationFailureEvent,
final FormDefinitionGenerator formDefinitionGenerator); @Override void generateProcessForm(final Diagram diagram); @Override void generateAllForms(final Diagram diagram); @Override void generateSelectedForms(final Diagram diagram,
final String[] ids); }### Answer:
@Test public void testGenerateProcessForm() { testGenerateProcessForm(false); } |
### Question:
FormGenerationServiceImpl implements FormGenerationService { @Override public void generateSelectedForms(final Diagram diagram, final String[] ids) { this.doGenerate(diagram, () -> formDefinitionGenerator.generateSelectedForms(diagram, ids)); } protected FormGenerationServiceImpl(); @Inject FormGenerationServiceImpl(final Event<FormGeneratedEvent> formGeneratedEvent,
final Event<FormGenerationFailureEvent> formGenerationFailureEvent,
final FormDefinitionGenerator formDefinitionGenerator); @Override void generateProcessForm(final Diagram diagram); @Override void generateAllForms(final Diagram diagram); @Override void generateSelectedForms(final Diagram diagram,
final String[] ids); }### Answer:
@Test public void testGenerateSelectedForms() { testGenerateSelectedForms(false); } |
### Question:
FormGenerationServiceImpl implements FormGenerationService { @Override public void generateAllForms(final Diagram diagram) { doGenerate(diagram, () -> formDefinitionGenerator.generateAllForms(diagram)); } protected FormGenerationServiceImpl(); @Inject FormGenerationServiceImpl(final Event<FormGeneratedEvent> formGeneratedEvent,
final Event<FormGenerationFailureEvent> formGenerationFailureEvent,
final FormDefinitionGenerator formDefinitionGenerator); @Override void generateProcessForm(final Diagram diagram); @Override void generateAllForms(final Diagram diagram); @Override void generateSelectedForms(final Diagram diagram,
final String[] ids); }### Answer:
@Test public void testGenerateAllForms() { testGenerateAllForms(false); } |
### Question:
FormDefinitionGeneratorImpl implements FormDefinitionGenerator { @Override public void generateProcessForm(Diagram diagram) { try { LOGGER.finest("Generating form for process "); final Definitions definitions = toDefinitions(diagram); final Path path = diagram.getMetadata().getPath(); final BusinessProcessFormModel formModel = bpmnFormModelGenerator.generateProcessFormModel(definitions, path); createFormForModel(formModel, Paths.convert(path)); } catch (Exception ex) { LOGGER.severe("Error generating process form"); throw new RuntimeException(ex); } } @Inject FormDefinitionGeneratorImpl(FormGenerationModelProviders providers,
@Named("ioStrategy") final IOService ioService,
final BPMNFormModelGenerator bpmnFormModelGenerator,
final FormDefinitionSerializer serializer,
@Authoring final BPMNFormGeneratorService<Path> bpmnFormGeneratorService); @Override void generateProcessForm(Diagram diagram); @Override void generateSelectedForms(Diagram diagram, String... taskIds); @Override void generateAllForms(Diagram diagram); void createFormForModel(JBPMFormModel formModel, org.uberfire.java.nio.file.Path path); }### Answer:
@Test public void testGenerateProcessForm() { generator.generateProcessForm(diagram); verify(generator, times(1)).createFormForModel(formModelArgumentCaptor.capture(), any()); verify(formDefinitionSerializer, times(1)).serialize(formDefinitionArgumentCaptor.capture()); verify(ioService, times(1)).createFile(any()); verify(ioService, times(1)).write(any(), anyString()); JBPMFormModel formModel = formModelArgumentCaptor.getValue(); Assertions.assertThat(formModel) .isNotNull() .isInstanceOf(BusinessProcessFormModel.class); checkProcessFormGenerated((BusinessProcessFormModel) formModel, formDefinitionArgumentCaptor.getValue()); } |
### Question:
FormDefinitionGeneratorImpl implements FormDefinitionGenerator { @Override public void generateAllForms(Diagram diagram) { try { LOGGER.finest("Generating all forms"); final Path path = diagram.getMetadata().getPath(); final org.uberfire.java.nio.file.Path nioPath = Paths.convert(path); ioService.startBatch(ioService.getFileSystem(nioPath.toUri())); final Definitions definitions = toDefinitions(diagram); final BusinessProcessFormModel processFormModel = bpmnFormModelGenerator.generateProcessFormModel(definitions, path); createFormForModel(processFormModel, nioPath); List<TaskFormModel> taskFormModels = bpmnFormModelGenerator.generateTaskFormModels(definitions, path); for (TaskFormModel taskFormModel : taskFormModels) { createFormForModel(taskFormModel, nioPath); } } catch (Exception ex) { LOGGER.severe("Error generating all diagram forms"); throw new RuntimeException(ex); } finally { ioService.endBatch(); } } @Inject FormDefinitionGeneratorImpl(FormGenerationModelProviders providers,
@Named("ioStrategy") final IOService ioService,
final BPMNFormModelGenerator bpmnFormModelGenerator,
final FormDefinitionSerializer serializer,
@Authoring final BPMNFormGeneratorService<Path> bpmnFormGeneratorService); @Override void generateProcessForm(Diagram diagram); @Override void generateSelectedForms(Diagram diagram, String... taskIds); @Override void generateAllForms(Diagram diagram); void createFormForModel(JBPMFormModel formModel, org.uberfire.java.nio.file.Path path); }### Answer:
@Test public void testGenerateAllForms() { generator.generateAllForms(diagram); verify(generator, times(4)).createFormForModel(formModelArgumentCaptor.capture(), any()); verify(formDefinitionSerializer, times(4)).serialize(formDefinitionArgumentCaptor.capture()); verify(ioService, times(1)).startBatch(any()); verify(ioService, times(1)).getFileSystem(any()); verify(ioService, times(4)).createFile(any()); verify(ioService, times(4)).write(any(), anyString()); verify(ioService, times(1)).endBatch(); List<JBPMFormModel> formModels = formModelArgumentCaptor.getAllValues(); List<FormDefinition> forms = formDefinitionArgumentCaptor.getAllValues(); Assertions.assertThat(formModels) .isNotEmpty() .hasSize(forms.size()) .hasSize(4); for (int i = 0; i < formModels.size(); i++) { JBPMFormModel formModel = formModels.get(i); FormDefinition form = forms.get(i); if (formModel instanceof BusinessProcessFormModel) { checkProcessFormGenerated((BusinessProcessFormModel) formModel, form); } else { TaskFormModel taskFormModel = (TaskFormModel) formModel; checkTaskFormGenerated(taskFormModel, taskFormModel.getTaskName(), form); } } } |
### Question:
FormGenerationModelProviders { public FormGenerationModelProvider<?> getModelProvider(final Diagram diagram) { for (FormGenerationModelProvider provider : providers) { if (provider.accepts(diagram)) { return provider; } } return null; } protected FormGenerationModelProviders(); @Inject FormGenerationModelProviders(final @Any Instance<FormGenerationModelProvider<?>> providers); FormGenerationModelProviders(final Iterable<FormGenerationModelProvider<?>> providers); FormGenerationModelProvider<?> getModelProvider(final Diagram diagram); }### Answer:
@Test public void testGetModelProviders() { assertEquals(provider1, tested.getModelProvider(diagram1)); assertEquals(provider2, tested.getModelProvider(diagram2)); } |
### Question:
FormGenerationNotifier { public void showNotification(final String message) { messageNotifier.accept(message); } protected FormGenerationNotifier(); @Inject FormGenerationNotifier(ClientTranslationService translationService); FormGenerationNotifier(ClientTranslationService translationService, Consumer<String> messageNotifier, Consumer<String> errorNotifier); void showNotification(final String message); void showError(final String message); }### Answer:
@Test public void testShowNotification() { notifier.showNotification(MESSAGE); verify(messageNotification, times(1)).accept(MESSAGE); verify(errorNotification, times(0)).accept(MESSAGE); } |
### Question:
FormGenerationNotifier { public void showError(final String message) { errorNotifier.accept(message); } protected FormGenerationNotifier(); @Inject FormGenerationNotifier(ClientTranslationService translationService); FormGenerationNotifier(ClientTranslationService translationService, Consumer<String> messageNotifier, Consumer<String> errorNotifier); void showNotification(final String message); void showError(final String message); }### Answer:
@Test public void testshowError() { notifier.showError(ERROR); verify(errorNotification, times(1)).accept(ERROR); verify(messageNotification, times(0)).accept(ERROR); } |
### Question:
FormGenerationToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid) { return translationService.getValue(FormsClientConstants.FormsGenerateTaskForm); } @Inject FormGenerationToolboxAction(final ClientTranslationService translationService,
final ClientFormGenerationManager formGenerationManager); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); }### Answer:
@Test public void testGetTitle() { assertEquals("generateTitle", tested.getTitle(canvasHandler, "uuid")); } |
### Question:
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions) { final List<DRGElement> importedNodes = new ArrayList<>(); importDefinitions.forEach((anImport, definitions) -> { importedNodes.addAll(getDrgElementsWithNamespace(definitions, anImport)); }); return importedNodes; } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); static final QName NAMESPACE; }### Answer:
@Test public void testGetImportedDRGElements() { final Map<Import, Definitions> importDefinitions = new HashMap<>(); final Import anImport = mock(Import.class); final Definitions definitions = mock(Definitions.class); final DRGElement drgElement1 = mock(DRGElement.class); final DRGElement drgElement2 = mock(DRGElement.class); final DRGElement drgElement3 = mock(DRGElement.class); final List<DRGElement> expectedDRGElements = asList(drgElement1, drgElement2, drgElement3); doReturn(expectedDRGElements).when(helper).getDrgElementsWithNamespace(definitions, anImport); importDefinitions.put(anImport, definitions); final List<DRGElement> actualDRGElements = helper.getImportedDRGElements(importDefinitions); assertEquals(expectedDRGElements, actualDRGElements); } |
### Question:
FormGenerationToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { formGenerationManager.call(service -> service.generateSelectedForms(canvasHandler.getDiagram(), new String[]{uuid})); return this; } @Inject FormGenerationToolboxAction(final ClientTranslationService translationService,
final ClientFormGenerationManager formGenerationManager); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); }### Answer:
@Test @SuppressWarnings("unchecked") public void testOnClick() { final MouseClickEvent event = mock(MouseClickEvent.class); tested.onMouseClick(canvasHandler, "uuid", event); verify(formGenerationManager, times(1)).call(any(Consumer.class)); verify(formGenerationService, times(1)).generateSelectedForms(eq(diagram), eq(new String[]{"uuid"})); } |
### Question:
FormsCanvasSessionHandler { @SuppressWarnings("unchecked") public boolean executeUpdateDomainObjectProperty(final DomainObject domainObject, final String fieldName, final Object value) { return execute(commandFactory.updateDomainObjectPropertyValue(domainObject, fieldName, value), domainObjectCanvasListener); } @Inject FormsCanvasSessionHandler(final DefinitionManager definitionManager,
final CanvasCommandFactory<AbstractCanvasHandler> commandFactory,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager); FormsCanvasSessionHandler setRenderer(FormRenderer renderer); FormsCanvasSessionHandler bind(final ClientSession session); FormsCanvasSessionHandler unbind(); @PreDestroy void destroy(); void show(); @SuppressWarnings("unchecked") void show(final Command callback); @SuppressWarnings("unchecked") boolean executeUpdateProperty(final Element<? extends Definition<?>> element,
final String fieldName,
final Object value); @SuppressWarnings("unchecked") boolean executeUpdateDomainObjectProperty(final DomainObject domainObject,
final String fieldName,
final Object value); ClientSession getSession(); AbstractCanvasHandler getCanvasHandler(); Diagram<?, ?> getDiagram(); RenderMode getSessionRenderMode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecuteUpdateDomainObjectProperty() { handler.bind(session); handler.executeUpdateDomainObjectProperty(domainObject, FIELD_NAME, FIELD_VALUE); final InOrder inOrder = inOrder(domainObjectCanvasListener, commandFactory, sessionCommandManager, domainObjectCanvasListener); inOrder.verify(commandFactory).updateDomainObjectPropertyValue(domainObject, FIELD_NAME, FIELD_VALUE); inOrder.verify(domainObjectCanvasListener).startProcessing(); inOrder.verify(sessionCommandManager).execute(abstractCanvasHandler, updateDomainObjectPropertyCommand); inOrder.verify(domainObjectCanvasListener).endProcessing(); } |
### Question:
FormPropertiesWidget implements IsElement,
FormPropertiesWidgetView.Presenter { protected void fireFormsPropertiesOpenedEvent(String uuid, String name) { propertiesOpenedEvent.fire(new FormPropertiesOpened(formSessionHandler.getSession(), uuid, name)); } @Inject FormPropertiesWidget(final FormPropertiesWidgetView view,
final DefinitionUtils definitionUtils,
final FormsCanvasSessionHandler formSessionHandler,
final Event<FormPropertiesOpened> propertiesOpenedEvent,
final FormsContainer formsContainer,
final FormsFlushManager formsFlushManager,
final TranslationService translationService); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override HTMLElement getElement(); @Override HTMLElement getDisplayerElement(); FormsCanvasSessionHandler getFormSessionHandler(); @SuppressWarnings("unchecked") FormPropertiesWidget bind(final ClientSession session); @SuppressWarnings("unchecked") FormPropertiesWidget unbind(); @PreDestroy void destroy(); void show(); @SuppressWarnings("unchecked") void show(final Command callback); void resetLastElementRenderedCache(); boolean areLastPositionsForSameElementSame(final Element element); }### Answer:
@Test public void testFireFormsPropertiesOpenedEvent() { tested.fireFormsPropertiesOpenedEvent("", ""); verify(propertiesOpenedEvent, times(1)).fire(formPropertiesOpenedArgumentCaptor.capture()); } |
### Question:
FormPropertiesWidget implements IsElement,
FormPropertiesWidgetView.Presenter { protected static boolean isNode(final Element<? extends Definition<?>> element) { return element instanceof Node; } @Inject FormPropertiesWidget(final FormPropertiesWidgetView view,
final DefinitionUtils definitionUtils,
final FormsCanvasSessionHandler formSessionHandler,
final Event<FormPropertiesOpened> propertiesOpenedEvent,
final FormsContainer formsContainer,
final FormsFlushManager formsFlushManager,
final TranslationService translationService); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override HTMLElement getElement(); @Override HTMLElement getDisplayerElement(); FormsCanvasSessionHandler getFormSessionHandler(); @SuppressWarnings("unchecked") FormPropertiesWidget bind(final ClientSession session); @SuppressWarnings("unchecked") FormPropertiesWidget unbind(); @PreDestroy void destroy(); void show(); @SuppressWarnings("unchecked") void show(final Command callback); void resetLastElementRenderedCache(); boolean areLastPositionsForSameElementSame(final Element element); }### Answer:
@Test public void testIsNode() { NodeImpl node = mock(NodeImpl.class); assertTrue(FormPropertiesWidget.isNode(node)); GraphImpl notNode = mock(GraphImpl.class); assertFalse(FormPropertiesWidget.isNode(notNode)); } |
### Question:
FormPropertiesWidget implements IsElement,
FormPropertiesWidgetView.Presenter { protected static boolean isFiltered(final Element<? extends Definition<?>> element) { final Definition content = element.getContent(); if (Objects.isNull(content)) { return false; } final Object definition = content.getDefinition(); return !FormFiltersProviderFactory.getFilterForDefinition(element.getUUID(), definition).isEmpty(); } @Inject FormPropertiesWidget(final FormPropertiesWidgetView view,
final DefinitionUtils definitionUtils,
final FormsCanvasSessionHandler formSessionHandler,
final Event<FormPropertiesOpened> propertiesOpenedEvent,
final FormsContainer formsContainer,
final FormsFlushManager formsFlushManager,
final TranslationService translationService); @PostConstruct @SuppressWarnings("unchecked") void init(); @Override HTMLElement getElement(); @Override HTMLElement getDisplayerElement(); FormsCanvasSessionHandler getFormSessionHandler(); @SuppressWarnings("unchecked") FormPropertiesWidget bind(final ClientSession session); @SuppressWarnings("unchecked") FormPropertiesWidget unbind(); @PreDestroy void destroy(); void show(); @SuppressWarnings("unchecked") void show(final Command callback); void resetLastElementRenderedCache(); boolean areLastPositionsForSameElementSame(final Element element); }### Answer:
@Test public void testIsFiltered() { NodeImpl nodeNullContent = mock(NodeImpl.class); when(nodeNullContent.getContent()).thenReturn(null); assertFalse(FormPropertiesWidget.isFiltered(nodeNullContent)); Definition content = mock(Definition.class); NodeImpl nodeUnfiltered = mock(NodeImpl.class); Object unfilteredDefinition = mock(Object.class); when(nodeUnfiltered.getContent()).thenReturn(content); when(content.getDefinition()).thenReturn(unfilteredDefinition); assertFalse(FormPropertiesWidget.isFiltered(nodeUnfiltered)); NodeImpl nodeFiltered = mock(NodeImpl.class); when(nodeFiltered.getContent()).thenReturn(content); when(content.getDefinition()).thenReturn(CUSTOM_DEFINITION); assertTrue(FormPropertiesWidget.isFiltered(nodeFiltered)); } |
### Question:
FormsFlushManager { void setCurrentContainer(FormsContainer container) { this.container = container; } void flush(ClientSession session,
String elementUUID); @PreDestroy void destroy(); }### Answer:
@Test public void setCurrentContainer() { tested.container = formsContainer; tested.setCurrentContainer(formsContainer); assertEquals(formsContainer, tested.container); } |
### Question:
FormsFlushManager { public void flush(ClientSession session, String elementUUID) { if (container != null) { container.flush(session.getCanvasHandler().getDiagram().getGraph().getUUID(), elementUUID); } } void flush(ClientSession session,
String elementUUID); @PreDestroy void destroy(); }### Answer:
@Test public void flush() { tested.container = null; tested.flush(clientSession, ELEMENT_UUID); tested.container = formsContainer; tested.flush(clientSession, ELEMENT_UUID); verify(formsContainer, times(1)).flush(GRAPH_UUID, ELEMENT_UUID); } |
### Question:
FormsFlushManager { @PreDestroy public void destroy() { this.container = null; } void flush(ClientSession session,
String elementUUID); @PreDestroy void destroy(); }### Answer:
@Test public void destroy() { FormsContainer formsContainer = mock(FormsContainer.class); tested.container = formsContainer; tested.destroy(); assertEquals(null, tested.container); } |
### Question:
FormsContainer implements IsElement { public void render(final String graphUuid, final String domainObjectUUID, final Object domainObject, final Path diagramPath, final FieldChangeHandler changeHandler, final RenderMode renderMode) { FormDisplayer displayer = getDisplayer(graphUuid, domainObjectUUID); displayer.render(domainObjectUUID, domainObject, diagramPath, changeHandler, renderMode); if (null != currentDisplayer && !displayer.equals(currentDisplayer)) { currentDisplayer.hide(); } displayer.show(); currentDisplayer = displayer; currentDisplayer.getRenderer().addFieldChangeHandler((name, value) -> { formFieldChangedEvent.fire(new FormFieldChanged(name, value, domainObjectUUID)); }); } @Inject FormsContainer(final FormsContainerView view,
final @Any ManagedInstance<FormDisplayer> displayersInstance,
final Event<FormFieldChanged> formFieldChangedEvent); void render(final String graphUuid,
final String domainObjectUUID,
final Object domainObject,
final Path diagramPath,
final FieldChangeHandler changeHandler,
final RenderMode renderMode); void clearDiagramDisplayers(final String graphUuid); void clearFormDisplayer(final String graphUuid,
final String elementUid); void flush(String graphUUID, String elementUUID); @Override HTMLElement getElement(); @PreDestroy void destroyAll(); }### Answer:
@Test public void testRenderExistingNode() { RenderMode renderMode = RenderMode.EDIT_MODE; NodeImpl<Definition<?>> firstNode = getNode(FIRST_ELEMENT_UUID); FormDisplayer firstDisplayer = testRender(firstNode, 1, 1, renderMode); NodeImpl secondNode = getNode(SECOND_ELEMENT_UUID); FormDisplayer secondDisplayer = testRender(secondNode, 2, 1, renderMode); formsContainer.render(GRAPH_UUID, firstNode.getUUID(), firstNode.getContent().getDefinition(), path, fieldChangeHandler, renderMode); verify(displayersInstance, times(2)).get(); verify(secondDisplayer, times(2)).hide(); verify(firstDisplayer, times(2)).show(); verify(firstDisplayer, times(2)).render(firstNode.getUUID(), firstNode.getContent().getDefinition(), path, fieldChangeHandler, renderMode); } |
### Question:
FormsContainer implements IsElement { public void clearDiagramDisplayers(final String graphUuid) { LOGGER.fine("Clearing properties forms for graph: " + graphUuid); List<FormDisplayerKey> keys = formDisplayers.keySet() .stream() .filter(entry -> entry.getGraphUuid().equals(graphUuid)).collect(Collectors.toList()); keys.forEach(this::clearDisplayer); LOGGER.fine("Cleared properties forms for graph: " + graphUuid); } @Inject FormsContainer(final FormsContainerView view,
final @Any ManagedInstance<FormDisplayer> displayersInstance,
final Event<FormFieldChanged> formFieldChangedEvent); void render(final String graphUuid,
final String domainObjectUUID,
final Object domainObject,
final Path diagramPath,
final FieldChangeHandler changeHandler,
final RenderMode renderMode); void clearDiagramDisplayers(final String graphUuid); void clearFormDisplayer(final String graphUuid,
final String elementUid); void flush(String graphUUID, String elementUUID); @Override HTMLElement getElement(); @PreDestroy void destroyAll(); }### Answer:
@Test public void testDestroyDiagramDisplayers() { RenderMode renderMode = RenderMode.EDIT_MODE; FormDisplayer firstDisplayer = testRender(getNode(FIRST_ELEMENT_UUID), 1, 1, renderMode); FormDisplayer secondDisplayer = testRender(getNode(SECOND_ELEMENT_UUID), 2, 1, renderMode); formsContainer.clearDiagramDisplayers(GRAPH_UUID); verify(firstDisplayer, times(3)).hide(); verify(view, times(1)).removeDisplayer(firstDisplayer); verify(displayersInstance, times(1)).destroy(firstDisplayer); verify(secondDisplayer, times(2)).hide(); verify(view, times(1)).removeDisplayer(secondDisplayer); verify(displayersInstance, times(1)).destroy(secondDisplayer); } |
### Question:
FormsContainer implements IsElement { public void clearFormDisplayer(final String graphUuid, final String elementUid) { formDisplayers.keySet() .stream() .filter(key -> key.getGraphUuid().equals(graphUuid) && key.getElementUid().equals(elementUid)) .findAny() .ifPresent(this::clearDisplayer); } @Inject FormsContainer(final FormsContainerView view,
final @Any ManagedInstance<FormDisplayer> displayersInstance,
final Event<FormFieldChanged> formFieldChangedEvent); void render(final String graphUuid,
final String domainObjectUUID,
final Object domainObject,
final Path diagramPath,
final FieldChangeHandler changeHandler,
final RenderMode renderMode); void clearDiagramDisplayers(final String graphUuid); void clearFormDisplayer(final String graphUuid,
final String elementUid); void flush(String graphUUID, String elementUUID); @Override HTMLElement getElement(); @PreDestroy void destroyAll(); }### Answer:
@Test public void testDestroyOneDisplayer() { RenderMode renderMode = RenderMode.EDIT_MODE; NodeImpl firstNode = getNode(FIRST_ELEMENT_UUID); FormDisplayer firstDisplayer = testRender(firstNode, 1, 1, renderMode); NodeImpl secondNode = getNode(SECOND_ELEMENT_UUID); FormDisplayer secondDisplayer = testRender(secondNode, 2, 1, renderMode); formsContainer.clearFormDisplayer(GRAPH_UUID, FIRST_ELEMENT_UUID); verify(firstDisplayer, times(3)).hide(); verify(view, times(1)).removeDisplayer(firstDisplayer); verify(displayersInstance, times(1)).destroy(firstDisplayer); verify(secondDisplayer, times(1)).hide(); verify(view, never()).removeDisplayer(secondDisplayer); verify(displayersInstance, never()).destroy(secondDisplayer); formsContainer.clearFormDisplayer(GRAPH_UUID, SECOND_ELEMENT_UUID); verify(secondDisplayer, times(2)).hide(); verify(view, times(1)).removeDisplayer(secondDisplayer); verify(displayersInstance, times(1)).destroy(secondDisplayer); } |
### Question:
FormsContainer implements IsElement { @PreDestroy public void destroyAll() { view.clear(); currentDisplayer = null; displayersInstance.destroyAll(); formDisplayers.clear(); currentDisplayer = null; } @Inject FormsContainer(final FormsContainerView view,
final @Any ManagedInstance<FormDisplayer> displayersInstance,
final Event<FormFieldChanged> formFieldChangedEvent); void render(final String graphUuid,
final String domainObjectUUID,
final Object domainObject,
final Path diagramPath,
final FieldChangeHandler changeHandler,
final RenderMode renderMode); void clearDiagramDisplayers(final String graphUuid); void clearFormDisplayer(final String graphUuid,
final String elementUid); void flush(String graphUUID, String elementUUID); @Override HTMLElement getElement(); @PreDestroy void destroyAll(); }### Answer:
@Test public void testDestroyAllDisplayers() { RenderMode renderMode = RenderMode.EDIT_MODE; testRender(getNode(FIRST_ELEMENT_UUID), 1, 1, renderMode); testRender(getNode(SECOND_ELEMENT_UUID), 2, 1, renderMode); formsContainer.destroyAll(); verify(view, times(1)).clear(); verify(displayersInstance, times(1)).destroyAll(); } |
### Question:
FormsContainer implements IsElement { public void flush(String graphUUID, String elementUUID) { FormDisplayer displayer = getDisplayer(graphUUID, elementUUID); DynamicFormRenderer renderer = displayer.getRenderer(); renderer.flush(); } @Inject FormsContainer(final FormsContainerView view,
final @Any ManagedInstance<FormDisplayer> displayersInstance,
final Event<FormFieldChanged> formFieldChangedEvent); void render(final String graphUuid,
final String domainObjectUUID,
final Object domainObject,
final Path diagramPath,
final FieldChangeHandler changeHandler,
final RenderMode renderMode); void clearDiagramDisplayers(final String graphUuid); void clearFormDisplayer(final String graphUuid,
final String elementUid); void flush(String graphUUID, String elementUUID); @Override HTMLElement getElement(); @PreDestroy void destroyAll(); }### Answer:
@Test public void testflush() { DynamicFormRenderer dynamicFormRenderer = mock(DynamicFormRenderer.class); FormDisplayer formDisplayer = mock(FormDisplayer.class); when(formDisplayer.getRenderer()).thenReturn(dynamicFormRenderer); FormsContainer formsContainer = mock(FormsContainer.class); when(formsContainer.getDisplayer(GRAPH_UUID, FIRST_ELEMENT_UUID)).thenReturn(formDisplayer); doCallRealMethod().when(formsContainer).flush(GRAPH_UUID, FIRST_ELEMENT_UUID); formsContainer.flush(GRAPH_UUID, FIRST_ELEMENT_UUID); verify(dynamicFormRenderer, times(1)).flush(); } |
### Question:
FormsContainer implements IsElement { protected FormDisplayer getDisplayer(final String graphUuid, final String elementUuid) { FormDisplayerKey key = new FormDisplayerKey(graphUuid, elementUuid); FormDisplayer displayer = formDisplayers.get(key); LOGGER.fine("Getting form displayer for : " + key); if (displayer != null) { return displayer; } LOGGER.fine("Creating new form displayer for : " + key); displayer = displayersInstance.get(); displayer.hide(); view.addDisplayer(displayer); formDisplayers.put(new FormDisplayerKey(graphUuid, elementUuid), displayer); return displayer; } @Inject FormsContainer(final FormsContainerView view,
final @Any ManagedInstance<FormDisplayer> displayersInstance,
final Event<FormFieldChanged> formFieldChangedEvent); void render(final String graphUuid,
final String domainObjectUUID,
final Object domainObject,
final Path diagramPath,
final FieldChangeHandler changeHandler,
final RenderMode renderMode); void clearDiagramDisplayers(final String graphUuid); void clearFormDisplayer(final String graphUuid,
final String elementUid); void flush(String graphUUID, String elementUUID); @Override HTMLElement getElement(); @PreDestroy void destroyAll(); }### Answer:
@Test public void testGetDisplayer() { FormDisplayer formDisplayer1 = mock(FormDisplayer.class); FormDisplayer formDisplayer2 = mock(FormDisplayer.class); ManagedInstance managedInstance = mock(ManagedInstance.class); when(managedInstance.get()).thenReturn(formDisplayer2); FormsContainerView formsContainerView = mock(FormsContainerView.class); FormsContainer formsContainer = new FormsContainer(formsContainerView, managedInstance, null); formsContainer.formDisplayers.put(new FormDisplayerKey(GRAPH_UUID, FIRST_ELEMENT_UUID), formDisplayer1); FormDisplayer result1 = formsContainer.getDisplayer(GRAPH_UUID, FIRST_ELEMENT_UUID); FormDisplayer result2 = formsContainer.getDisplayer(GRAPH_UUID, SECOND_ELEMENT_UUID); assertEquals(formDisplayer1, result1); assertEquals(formDisplayer2, result2); } |
### Question:
GenerateDiagramFormsSessionCommand extends AbstractClientSessionCommand<EditorSession> { @Override public <V> void execute(Callback<V> callback) { formGenerationManager.call(this::call); callback.onSuccess(); } protected GenerateDiagramFormsSessionCommand(); @Inject GenerateDiagramFormsSessionCommand(final ClientFormGenerationManager formGenerationManager); @Override void execute(Callback<V> callback); @Override boolean accepts(final ClientSession session); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGenerate() { final ClientSessionCommand.Callback callback = mock(ClientSessionCommand.Callback.class); tested.execute(callback); verify(formGenerationService, times(1)).generateAllForms(eq(diagram)); verify(callback, times(1)).onSuccess(); verify(callback, never()).onError(anyObject()); } |
### Question:
ExpressionEditorGridRow extends BaseGridRow { @Override public double getHeight() { long currentTimeMillis = log(LOGGER, " - Pre- ExpressionEditorGridRow.getHeight()"); final double height = this.getCells() .values() .stream() .filter(cell -> cell != null && cell.getValue() != null) .map(GridCell::getValue) .filter(value -> value instanceof ExpressionCellValue) .map(value -> (ExpressionCellValue) value) .filter(value -> value.getValue().isPresent()) .map(value -> value.getValue().get()) .map(editor -> editor.getHeight() + editor.getPadding() * 2) .reduce(Double::max) .orElse(defaultHeight); log(LOGGER, " - Post- ExpressionEditorGridRow.getHeight()", currentTimeMillis); return height; } ExpressionEditorGridRow(); ExpressionEditorGridRow(final double height); @Override double getHeight(); static final double DEFAULT_HEIGHT; }### Answer:
@Test public void testEmptyRow() { final GridRow row = new ExpressionEditorGridRow(); assertThat(row.getHeight()).isEqualTo(DEFAULT_HEIGHT); }
@Test @SuppressWarnings("unchecked") public void testRowLowerThanDefault() { when(view.getHeight()).thenReturn(DEFAULT_HEIGHT - 1); final GridRow row = spy(ExpressionEditorGridRow.class); final Map<Integer, GridCell<?>> cells = new Maps.Builder<Integer, GridCell<?>>() .put(0, new BaseGridCell<>(new ExpressionCellValue(Optional.of(view)))) .build(); when(row.getCells()).thenReturn(cells); assertThat(row.getHeight()).isBetween(0D, DEFAULT_HEIGHT); }
@Test @SuppressWarnings("unchecked") public void testRowHigherThanDefault() { when(view.getHeight()).thenReturn(DEFAULT_HEIGHT + 1); final GridRow row = spy(ExpressionEditorGridRow.class); final Map<Integer, GridCell<?>> cells = new Maps.Builder<Integer, GridCell<?>>() .put(0, new BaseGridCell<>(new ExpressionCellValue(Optional.of(view)))) .build(); when(row.getCells()).thenReturn(cells); assertThat(row.getHeight()).isGreaterThan(DEFAULT_HEIGHT); }
@Test @SuppressWarnings("unchecked") public void testRowHigherThanDefaultWithNullCell() { when(view.getHeight()).thenReturn(DEFAULT_HEIGHT + 1); final GridRow row = spy(ExpressionEditorGridRow.class); final Map<Integer, GridCell<?>> cells = new Maps.Builder<Integer, GridCell<?>>() .put(0, new BaseGridCell<>(new ExpressionCellValue(Optional.of(view)))) .put(1, null) .build(); when(row.getCells()).thenReturn(cells); assertThat(row.getHeight()).isGreaterThan(DEFAULT_HEIGHT); }
@Test @SuppressWarnings("unchecked") public void testRowHigherThanDefaultWithNullCellValue() { when(view.getHeight()).thenReturn(DEFAULT_HEIGHT + 1); final GridRow row = spy(ExpressionEditorGridRow.class); final Map<Integer, GridCell<?>> cells = new Maps.Builder<Integer, GridCell<?>>() .put(0, new BaseGridCell<>(new ExpressionCellValue(Optional.of(view)))) .put(1, new BaseGridCell<>(null)) .build(); when(row.getCells()).thenReturn(cells); assertThat(row.getHeight()).isGreaterThan(DEFAULT_HEIGHT); } |
### Question:
GenerateProcessFormsSessionCommand extends AbstractClientSessionCommand<EditorSession> { @Override public <V> void execute(Callback<V> callback) { formGenerationManager.call(this::call); callback.onSuccess(); } protected GenerateProcessFormsSessionCommand(); @Inject GenerateProcessFormsSessionCommand(final ClientFormGenerationManager formGenerationManager); @Override void execute(Callback<V> callback); @Override boolean accepts(final ClientSession session); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGenerate() { final ClientSessionCommand.Callback callback = mock(ClientSessionCommand.Callback.class); tested.execute(callback); verify(formGenerationService, times(1)).generateProcessForm(eq(diagram)); verify(callback, times(1)).onSuccess(); verify(callback, never()).onError(anyObject()); } |
### Question:
GenerateSelectedFormsSessionCommand extends AbstractClientSessionCommand<EditorSession> { @Override public <V> void execute(Callback<V> callback) { formGenerationManager.call(this::call); callback.onSuccess(); } protected GenerateSelectedFormsSessionCommand(); @Inject GenerateSelectedFormsSessionCommand(final ClientFormGenerationManager formGenerationManager, final FormGenerationNotifier formGenerationNotifier, final ClientTranslationService translationService); GenerateSelectedFormsSessionCommand setElementAcceptor(final Predicate<Element> acceptor); @Override void execute(Callback<V> callback); @Override boolean accepts(final ClientSession session); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGenerateSelected() { final ClientSessionCommand.Callback callback = mock(ClientSessionCommand.Callback.class); tested.execute(callback); ArgumentCaptor<String[]> idsCaptor = ArgumentCaptor.forClass(String[].class); verify(formGenerationService, times(1)).generateSelectedForms(eq(diagram), idsCaptor.capture()); final String[] ids = idsCaptor.getValue(); assertTrue(Arrays.asList(ids).contains(ID1)); assertTrue(Arrays.asList(ids).contains(ID2)); verify(acceptor, times(1)).test(eq(element1)); verify(acceptor, times(1)).test(eq(element2)); verify(callback, times(1)).onSuccess(); verify(callback, never()).onError(anyObject()); verify(translationService, never()).getValue(FormsClientConstants.FormsNoItemsSelectedForGeneration); verify(formGenerationNotifier, never()).showNotification(anyString()); } |
### Question:
StunnerFormsHandler { public void refreshCurrentSessionForms() { refreshCurrentSessionForms(null); } StunnerFormsHandler(); @Inject StunnerFormsHandler(final SessionManager sessionManager,
final Event<RefreshFormPropertiesEvent> refreshFormsEvent); void refreshCurrentSessionForms(); void refreshCurrentSessionForms(final Class<?> defSetType); }### Answer:
@Test @SuppressWarnings("unchecked") public void testRefreshCurrentSessionForms() { ClientSession session = mock(ClientSession.class); when(sessionManager.getCurrentSession()).thenReturn(session); tested.refreshCurrentSessionForms(); ArgumentCaptor<RefreshFormPropertiesEvent> eventCaptor = ArgumentCaptor.forClass(RefreshFormPropertiesEvent.class); verify(refreshFormsEvent, times(1)).fire(eventCaptor.capture()); RefreshFormPropertiesEvent event = eventCaptor.getValue(); assertEquals(session, event.getSession()); assertNull(event.getUuid()); }
@Test @SuppressWarnings("unchecked") public void testRefreshCurrentSessionFormsByDomain() { ClientSession session = mock(ClientSession.class); CanvasHandler handler = mock(CanvasHandler.class); Diagram diagram = mock(Diagram.class); Metadata metadata = mock(Metadata.class); when(sessionManager.getCurrentSession()).thenReturn(session); when(session.getCanvasHandler()).thenReturn(handler); when(handler.getDiagram()).thenReturn(diagram); when(diagram.getMetadata()).thenReturn(metadata); when(metadata.getDefinitionSetId()).thenReturn(BindableAdapterUtils.getDefinitionSetId(SomeDomain.class)); tested.refreshCurrentSessionForms(SomeDomain.class); ArgumentCaptor<RefreshFormPropertiesEvent> eventCaptor = ArgumentCaptor.forClass(RefreshFormPropertiesEvent.class); verify(refreshFormsEvent, times(1)).fire(eventCaptor.capture()); RefreshFormPropertiesEvent event = eventCaptor.getValue(); assertEquals(session, event.getSession()); assertNull(event.getUuid()); }
@Test @SuppressWarnings("unchecked") public void testRefreshCurrentSessionFormsByNotMatchingDomain() { ClientSession session = mock(ClientSession.class); CanvasHandler handler = mock(CanvasHandler.class); Diagram diagram = mock(Diagram.class); Metadata metadata = mock(Metadata.class); when(sessionManager.getCurrentSession()).thenReturn(session); when(session.getCanvasHandler()).thenReturn(handler); when(handler.getDiagram()).thenReturn(diagram); when(diagram.getMetadata()).thenReturn(metadata); when(metadata.getDefinitionSetId()).thenReturn("ds1"); tested.refreshCurrentSessionForms(SomeDomain.class); verify(refreshFormsEvent, never()).fire(any(RefreshFormPropertiesEvent.class)); } |
### Question:
ClientFormGenerationManager { public void call(final Consumer<FormGenerationService> service) { service.accept(formGenerationService.call(getRemoteCallback(), getErrorCallback())); } protected ClientFormGenerationManager(); @Inject ClientFormGenerationManager(final ClientTranslationService translationService,
final FormGenerationNotifier formGenerationNotifier,
final Caller<FormGenerationService> formGenerationService); void call(final Consumer<FormGenerationService> service); }### Answer:
@Test @SuppressWarnings("unchecked") public void testCall() { final Consumer<FormGenerationService> consumer = mock(Consumer.class); tested.call(consumer); verify(consumer, times(1)).accept(eq(formGenerationService)); } |
### Question:
ClientFormGenerationManager { void onFormGeneratedEvent(@Observes FormGeneratedEvent event) { formGenerationNotifier.showNotification(translationService.getValue(FormsClientConstants.FormsGenerationSuccess, event.getName())); } protected ClientFormGenerationManager(); @Inject ClientFormGenerationManager(final ClientTranslationService translationService,
final FormGenerationNotifier formGenerationNotifier,
final Caller<FormGenerationService> formGenerationService); void call(final Consumer<FormGenerationService> service); }### Answer:
@Test public void testOnFormGenerationSuccess() { final FormGeneratedEvent event = mock(FormGeneratedEvent.class); when(event.getName()).thenReturn("name1"); tested.onFormGeneratedEvent(event); verify(translationService, times(1)).getValue(eq(FormsClientConstants.FormsGenerationSuccess), eq("name1")); verify(formGenerationNotifier, times(1)).showNotification(anyString()); verify(formGenerationNotifier, never()).showError(anyString()); } |
### Question:
ClientFormGenerationManager { void onFormGenerationFailureEvent(@Observes FormGenerationFailureEvent event) { formGenerationNotifier.showError(translationService.getValue(FormsClientConstants.FormsGenerationFailure, event.getName())); } protected ClientFormGenerationManager(); @Inject ClientFormGenerationManager(final ClientTranslationService translationService,
final FormGenerationNotifier formGenerationNotifier,
final Caller<FormGenerationService> formGenerationService); void call(final Consumer<FormGenerationService> service); }### Answer:
@Test public void testOnFormGenerationFailure() { final FormGenerationFailureEvent event = mock(FormGenerationFailureEvent.class); when(event.getName()).thenReturn("name1"); tested.onFormGenerationFailureEvent(event); verify(translationService, times(1)).getValue(eq(FormsClientConstants.FormsGenerationFailure), eq("name1")); verify(formGenerationNotifier, times(1)).showError(anyString()); verify(formGenerationNotifier, never()).showNotification(anyString()); } |
### Question:
RefreshFormPropertiesEvent implements UberFireEvent { public ClientSession getSession() { return session; } RefreshFormPropertiesEvent(final ClientSession session); RefreshFormPropertiesEvent(final ClientSession session,
final String uuid); boolean hasUuid(); String getUuid(); ClientSession getSession(); }### Answer:
@Test public void testGetSession() { assertThat(event.getSession()).isEqualTo(session); } |
### Question:
RefreshFormPropertiesEvent implements UberFireEvent { public String getUuid() { return uuid; } RefreshFormPropertiesEvent(final ClientSession session); RefreshFormPropertiesEvent(final ClientSession session,
final String uuid); boolean hasUuid(); String getUuid(); ClientSession getSession(); }### Answer:
@Test public void testGetUUID() { assertThat(event.getUuid()).isEqualTo(UUID); } |
### Question:
IntegrationHandlerProvider { public Optional<IntegrationHandler> getIntegrationHandler() { return integrationHandler; } IntegrationHandlerProvider(); @Inject IntegrationHandlerProvider(@Any final Instance<IntegrationHandler> integrationHandlerInstance); Optional<IntegrationHandler> getIntegrationHandler(); }### Answer:
@Test public void testIntegrationHandlerProviderWhenIntegrationIsPresent() { IntegrationHandler integrationHandler = mock(IntegrationHandler.class); integrationHandlers.add(integrationHandler); when(integrationHandlerInstance.iterator()).thenReturn(integrationHandlers.iterator()); integrationHandlerProvider = new IntegrationHandlerProvider(integrationHandlerInstance); assertTrue(integrationHandlerProvider.getIntegrationHandler().isPresent()); assertEquals(integrationHandler, integrationHandlerProvider.getIntegrationHandler().get()); }
@Test public void testIntegrationHandlerProviderWhenIntegrationIsNotPresent() { when(integrationHandlerInstance.iterator()).thenReturn(integrationHandlers.iterator()); integrationHandlerProvider = new IntegrationHandlerProvider(integrationHandlerInstance); assertFalse(integrationHandlerProvider.getIntegrationHandler().isPresent()); } |
### Question:
IntegrationHandlerImpl implements IntegrationHandler { @Override public void migrateFromJBPMDesignerToStunner(Path path, PlaceRequest place, boolean isDirty, ParameterizedCommand<Consumer<Boolean>> saveCommand) { checkIfDirtyAndMigrate(isDirty, saveCommand, () -> fromJBPMDesignerToStunner(path, place)); } IntegrationHandlerImpl(); @Inject IntegrationHandlerImpl(final Caller<IntegrationService> integrationService,
final PlaceManager placeManger,
final PopupUtil popupUtil,
final ErrorPopupPresenter errorPopup,
final MarshallingResponsePopup responsePopup,
final ClientTranslationService translationService,
final Event<NotificationEvent> notification); @Override void migrateFromJBPMDesignerToStunner(Path path, PlaceRequest place, boolean isDirty, ParameterizedCommand<Consumer<Boolean>> saveCommand); @Override void migrateFromStunnerToJBPMDesigner(Path path, PlaceRequest place, boolean isDirty, ParameterizedCommand<Consumer<Boolean>> saveCommand); }### Answer:
@Test public void testMigrateFromJBPMDesignerToStunnerWithUnexpectedError() { prepareServiceCallerError(integrationService, integrationServiceCaller, new Throwable(ERROR)); handler.migrateFromJBPMDesignerToStunner(jbpmPath, place, false, saveSuccessfulCommand); verifyUserWasAskedForStartingToStunnerMigrationAndRespond(true); String expectedMessage = MigrateActionUnexpectedErrorMessage + "\n" + ERROR; verify(errorPopup).showMessage(expectedMessage); }
@Test @SuppressWarnings("unchecked") public void testMigrateFromJBPMDesignerToStunnerWithUnexpectedErrorNoDiagramWasReturned() { MarshallingResponse<ProjectDiagram> marshallingResponse = new MarshallingResponse.MarshallingResponseBuilder<ProjectDiagram>() .state(MarshallingResponse.State.SUCCESS) .messages(Collections.EMPTY_LIST) .result(null) .build(); when(integrationService.getDiagramByPath(jbpmPath, MarshallingRequest.Mode.AUTO)).thenReturn(marshallingResponse); handler.migrateFromJBPMDesignerToStunner(jbpmPath, place, false, saveSuccessfulCommand); verifyUserWasAskedForStartingToStunnerMigrationAndRespond(true); verify(errorPopup).showMessage(MigrateToStunnerNoDiagramHasBeenReturned); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.