src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
KnowledgeBasesPresenter extends Section<ProjectScreenModel> { @Override public Promise<Void> setup(final ProjectScreenModel model) { this.kModuleModel = model.getKModule(); view.init(this); knowledgeBaseListPresenter.setup( view.getKnowledgeBasesTable(), model.getKModule().getKBases().values().stream().sorted(comparing(KBaseModel::getName)).collect(Collectors.toList()), (kbase, presenter) -> presenter.setup(kbase, this)); return promises.resolve(); } @Inject KnowledgeBasesPresenter(final View view,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final KnowledgeBaseListPresenter knowledgeBaseListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); @Override SectionView<?> getView(); @Override int currentHashCode(); }
|
@Test public void testSetup() { final ProjectScreenModel model = mock(ProjectScreenModel.class); when(model.getKModule()).thenReturn(spy(new KModuleModel())); when(model.getKModule().getKBases()).thenReturn(emptyMap()); knowledgeBasesPresenter.setup(model).catch_(i -> { Assert.fail("Promise should've been resolved!"); return promises.resolve(); }); verify(view).init(eq(knowledgeBasesPresenter)); verify(knowledgeBaseListPresenter).setup(any(), any(), any()); }
|
KnowledgeBasesPresenter extends Section<ProjectScreenModel> { @Override public Promise<Void> save(final String comment, final Supplier<Promise<Void>> chain) { kModuleModel.getKBases().clear(); kModuleModel.getKBases().putAll( knowledgeBaseListPresenter.getObjectsList().stream() .collect(Collectors.toMap(KBaseModel::getName, identity()))); return promises.resolve(); } @Inject KnowledgeBasesPresenter(final View view,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final KnowledgeBaseListPresenter knowledgeBaseListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); @Override SectionView<?> getView(); @Override int currentHashCode(); }
|
@Test public void testSave() { final KModuleModel kModuleModel = spy(new KModuleModel()); knowledgeBasesPresenter.kModuleModel = kModuleModel; final Map<String, KBaseModel> kBasesMap = spy(new HashMap<>()); doReturn(kBasesMap).when(kModuleModel).getKBases(); knowledgeBasesPresenter.save("Test comment", null).catch_(i -> { Assert.fail("Promise should've been resolved!"); return promises.resolve(); }); verify(kBasesMap).clear(); verify(kBasesMap).putAll(any()); }
|
KnowledgeBasesPresenter extends Section<ProjectScreenModel> { void addKnowledgeBase() { knowledgeBaseListPresenter.add(newKBaseModel("")); fireChangeEvent(); } @Inject KnowledgeBasesPresenter(final View view,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final KnowledgeBaseListPresenter knowledgeBaseListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); @Override SectionView<?> getView(); @Override int currentHashCode(); }
|
@Test public void testAddKnowledgeBase() { knowledgeBasesPresenter.addKnowledgeBase(); final KBaseModel kBaseModel = new KBaseModel(); kBaseModel.setName(""); kBaseModel.setDefault(knowledgeBaseListPresenter.getObjectsList().isEmpty()); verify(knowledgeBaseListPresenter).add(kBaseModel); verify(knowledgeBasesPresenter).fireChangeEvent(); }
|
KnowledgeBasesPresenter extends Section<ProjectScreenModel> { KBaseModel newKBaseModel(final String knowledgeBaseName) { final KBaseModel kBaseModel = new KBaseModel(); kBaseModel.setName(knowledgeBaseName); kBaseModel.setDefault(knowledgeBaseListPresenter.getObjectsList().isEmpty()); return kBaseModel; } @Inject KnowledgeBasesPresenter(final View view,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final KnowledgeBaseListPresenter knowledgeBaseListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); @Override SectionView<?> getView(); @Override int currentHashCode(); }
|
@Test public void testNewKBaseModelEmptyMap() { doReturn(emptyList()).when(knowledgeBaseListPresenter).getObjectsList(); final KBaseModel kBaseModel = knowledgeBasesPresenter.newKBaseModel("Name"); Assert.assertEquals("Name", kBaseModel.getName()); Assert.assertEquals(true, kBaseModel.isDefault()); }
@Test public void testNewKBaseModelNonEmptyMap() { doReturn(singletonList(new KBaseModel())).when(knowledgeBaseListPresenter).getObjectsList(); final KBaseModel kBaseModel = knowledgeBasesPresenter.newKBaseModel("Name"); Assert.assertEquals("Name", kBaseModel.getName()); Assert.assertEquals(false, kBaseModel.isDefault()); }
|
PropertiesItemPresenter extends ListItemPresenter<Property, PersistencePresenter, PropertiesItemPresenter.View> { @Override public PropertiesItemPresenter setup(final Property property, final PersistencePresenter parentPresenter) { this.property = property; this.parentPresenter = parentPresenter; view.init(this); view.setName(property.getName()); view.setValue(property.getValue()); return this; } @Inject PropertiesItemPresenter(final View view); @Override PropertiesItemPresenter setup(final Property property,
final PersistencePresenter parentPresenter); void onNameChange(final String name); void onValueChange(final String value); @Override Property getObject(); @Override void remove(); }
|
@Test public void testSetup() { propertiesItemPresenter.setup(new Property("Name", "Value"), mock(PersistencePresenter.class)); verify(view).init(eq(propertiesItemPresenter)); verify(view).setName(eq("Name")); verify(view).setValue(eq("Value")); }
|
PropertiesItemPresenter extends ListItemPresenter<Property, PersistencePresenter, PropertiesItemPresenter.View> { @Override public void remove() { super.remove(); parentPresenter.fireChangeEvent(); } @Inject PropertiesItemPresenter(final View view); @Override PropertiesItemPresenter setup(final Property property,
final PersistencePresenter parentPresenter); void onNameChange(final String name); void onValueChange(final String value); @Override Property getObject(); @Override void remove(); }
|
@Test public void testRemove() { final PersistencePresenter parentPresenter = mock(PersistencePresenter.class); final PropertiesListPresenter listPresenter = mock(PropertiesListPresenter.class); propertiesItemPresenter.parentPresenter = parentPresenter; propertiesItemPresenter.setListPresenter(listPresenter); propertiesItemPresenter.remove(); verify(listPresenter).remove(eq(propertiesItemPresenter)); verify(parentPresenter).fireChangeEvent(); }
|
PersistableDataObjectsItemPresenter extends ListItemPresenter<PersistableDataObject, PersistencePresenter, PersistableDataObjectsItemPresenter.View> { public PersistableDataObjectsItemPresenter setup(final PersistableDataObject className, final PersistencePresenter parentPresenter) { this.parentPresenter = parentPresenter; this.persistableDataObjects = className; view.init(this); view.setClassName(className.getValue()); return this; } @Inject PersistableDataObjectsItemPresenter(final View view); PersistableDataObjectsItemPresenter setup(final PersistableDataObject className,
final PersistencePresenter parentPresenter); void onClassNameChange(final String className); @Override PersistableDataObject getObject(); void remove(); View getView(); }
|
@Test public void testSetup() { persistableDataObjectsItemPresenter.setup(new PersistableDataObject("ClassName"), mock(PersistencePresenter.class)); verify(view).init(eq(persistableDataObjectsItemPresenter)); verify(view).setClassName(eq("ClassName")); }
|
PersistableDataObjectsItemPresenter extends ListItemPresenter<PersistableDataObject, PersistencePresenter, PersistableDataObjectsItemPresenter.View> { public void remove() { super.remove(); parentPresenter.fireChangeEvent(); } @Inject PersistableDataObjectsItemPresenter(final View view); PersistableDataObjectsItemPresenter setup(final PersistableDataObject className,
final PersistencePresenter parentPresenter); void onClassNameChange(final String className); @Override PersistableDataObject getObject(); void remove(); View getView(); }
|
@Test public void testRemove() { final PersistencePresenter parentPresenter = mock(PersistencePresenter.class); final PersistableDataObjectsListPresenter listPresenter = mock(PersistableDataObjectsListPresenter.class); persistableDataObjectsItemPresenter.parentPresenter = parentPresenter; persistableDataObjectsItemPresenter.setListPresenter(listPresenter); persistableDataObjectsItemPresenter.remove(); verify(listPresenter).remove(eq(persistableDataObjectsItemPresenter)); verify(parentPresenter).fireChangeEvent(); }
|
PersistencePresenter extends Section<ProjectScreenModel> { @Override public Promise<Void> setup(final ProjectScreenModel model) { return setup(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testSetup() { final PersistenceDescriptorEditorContent model = spy(newPersistenceDescriptorEditorContent()); doReturn(model).when(editorService).loadContent(any(), anyBoolean()); persistencePresenter.setup(mock(ProjectScreenModel.class)).catch_(i -> { Assert.fail("Promise should've been resolved!"); return promises.resolve(); }); verify(view).init(eq(persistencePresenter)); verify(editorService).loadContent(any(), anyBoolean()); verify(propertiesListPresenter).setup(any(), any(), any()); verify(persistableDataObjectsListPresenter).setup(any(), any(), any()); verify(view).setPersistenceUnit(model.getDescriptorModel().getPersistenceUnit().getName()); verify(view).setPersistenceProvider(model.getDescriptorModel().getPersistenceUnit().getProvider()); verify(view).setDataSource(eq(model.getDescriptorModel().getPersistenceUnit().getJtaDataSource())); }
@Test public void testSetupFail() { final RuntimeException testException = new RuntimeException("Test exception"); doThrow(testException).when(editorService).loadContent(any(), anyBoolean()); persistencePresenter.setup(mock(ProjectScreenModel.class)).then(i -> { Assert.fail("Promise should've not been resolved!"); return promises.resolve(); }).catch_(o -> promises.catchOrExecute(o, e -> promises.resolve(), e -> { Assert.fail("RPC failed so default RPC error handler was called."); return promises.resolve(); })); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void add(final String className) { persistableDataObjectsListPresenter.add(new PersistableDataObject(className)); fireChangeEvent(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testAddProperty() { final Property property = new Property("Name", "Value"); persistencePresenter.add(property); verify(propertiesListPresenter).add(eq(property)); }
@Test public void testAddPersistableDataObject() { final String className = "ClassName"; persistencePresenter.add(className); verify(persistableDataObjectsListPresenter).add(eq(new PersistableDataObject(className))); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void addAllProjectsPersistableDataObjects() { promises.promisify(dataModelerService, s -> { return s.findPersistableClasses(pathToPersistenceXml); }).then(classes -> { classes.stream() .filter(clazz -> !getPersistenceUnitModel().getClasses().contains(clazz)) .forEach(this::add); return promises.resolve(); }); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testAddAllProjectsPersistableDataObjects() { persistencePresenter.persistenceDescriptorEditorContent = newPersistenceDescriptorEditorContent(); doReturn(Arrays.asList("NewClass1", "NewClass2")).when(dataModelerService).findPersistableClasses(any()); persistencePresenter.addAllProjectsPersistableDataObjects(); verify(dataModelerService).findPersistableClasses(any()); verify(persistencePresenter, never()).add(eq("Class1")); verify(persistencePresenter).add(eq("NewClass1")); verify(persistencePresenter).add(eq("NewClass1")); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void addNewProperty() { add(new Property("", "")); fireChangeEvent(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testAddNewProperty() { persistencePresenter.addNewProperty(); verify(propertiesListPresenter).add(eq(new Property("", ""))); }
|
DeleteInputClauseCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler handler) { return new AbstractGraphCommand() { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext gce) { return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext gce) { dtable.getComponentWidths().remove(uiColumnIndex); final int clauseIndex = getInputClauseIndex(); dtable.getRule().forEach(row -> row.getInputEntry().remove(clauseIndex)); dtable.getInput().remove(clauseIndex); return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext gce) { dtable.getComponentWidths().add(uiColumnIndex, oldUiModelColumn.getWidth()); final int clauseIndex = getInputClauseIndex(); dtable.getInput().add(clauseIndex, oldInputClause); IntStream.range(0, dtable.getRule().size()) .forEach(rowIndex -> { final UnaryTests value = oldColumnData.get(rowIndex); dtable.getRule().get(rowIndex).getInputEntry().add(clauseIndex, value); }); return GraphCommandResultBuilder.SUCCESS; } }; } DeleteInputClauseCommand(final DecisionTable dtable,
final GridData uiModel,
final int uiColumnIndex,
final DecisionTableUIModelMapper uiModelMapper,
final org.uberfire.mvp.Command executeCanvasOperation,
final org.uberfire.mvp.Command undoCanvasOperation); void updateParentInformation(); }
|
@Test public void testGraphCommandAllow() throws Exception { final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.allow(graphCommandExecutionContext)); }
@Test public void testGraphCommandCheck() throws Exception { final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.allow(graphCommandExecutionContext)); }
@Test public void testGraphCommandExecuteRemoveMiddle() { final InputClause firstInput = mock(InputClause.class); final InputClause lastInput = mock(InputClause.class); dtable.getInput().add(0, firstInput); dtable.getInput().add(lastInput); final UnaryTests inputOneValue = mock(UnaryTests.class); final UnaryTests inputTwoValue = mock(UnaryTests.class); final UnaryTests inputThreeValue = mock(UnaryTests.class); final DecisionRule rule = new DecisionRule(); rule.getInputEntry().add(inputOneValue); rule.getInputEntry().add(inputTwoValue); rule.getInputEntry().add(inputThreeValue); dtable.getRule().add(rule); makeCommand(DecisionTableUIModelMapperHelper.ROW_INDEX_COLUMN_COUNT + 1); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.execute(graphCommandExecutionContext)); assertEquals(2, dtable.getInput().size()); assertEquals(firstInput, dtable.getInput().get(0)); assertEquals(lastInput, dtable.getInput().get(1)); assertEquals(2, dtable.getRule().get(0).getInputEntry().size()); assertEquals(inputOneValue, dtable.getRule().get(0).getInputEntry().get(0)); assertEquals(inputThreeValue, dtable.getRule().get(0).getInputEntry().get(1)); }
@Test public void testGraphCommandExecute() { final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.execute(graphCommandExecutionContext)); assertEquals(0, dtable.getInput().size()); }
@Test public void testGraphCommandExecuteAndThenUndo() { final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); graphCommand.execute(graphCommandExecutionContext); assertEquals(0, dtable.getInput().size()); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.undo(graphCommandExecutionContext)); assertEquals(1, dtable.getInput().size()); assertEquals(inputClause, dtable.getInput().get(0)); }
@Test public void testComponentWidths() { when(uiInputClauseColumn.getWidth()).thenReturn(DMNGridColumn.DEFAULT_WIDTH); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.execute(graphCommandExecutionContext)); assertEquals(dtable.getRequiredComponentWidthCount(), dtable.getComponentWidths().size()); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.undo(graphCommandExecutionContext)); assertEquals(dtable.getRequiredComponentWidthCount(), dtable.getComponentWidths().size()); assertEquals(DMNGridColumn.DEFAULT_WIDTH, dtable.getComponentWidths().get(DecisionTableUIModelMapperHelper.ROW_INDEX_COLUMN_COUNT), 0.0); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void addNewPersistableDataObject() { add(""); fireChangeEvent(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testAddNewPersistableDataObject() { persistencePresenter.addNewPersistableDataObject(); verify(persistableDataObjectsListPresenter).add(eq(new PersistableDataObject(""))); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void setPersistenceUnit(final String persistenceUnit) { getPersistenceUnitModel().setName(persistenceUnit); fireChangeEvent(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testSetPersistenceUnit() { final PersistenceDescriptorEditorContent model = newPersistenceDescriptorEditorContent(); persistencePresenter.persistenceDescriptorEditorContent = model; persistencePresenter.setPersistenceUnit("PersistenceUnit"); Assert.assertEquals("PersistenceUnit", model.getDescriptorModel().getPersistenceUnit().getName()); verify(persistencePresenter).fireChangeEvent(); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void setPersistenceProvider(final String persistenceProvider) { getPersistenceUnitModel().setProvider(persistenceProvider); fireChangeEvent(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testSetPersistenceProvider() { final PersistenceDescriptorEditorContent model = newPersistenceDescriptorEditorContent(); persistencePresenter.persistenceDescriptorEditorContent = model; persistencePresenter.setPersistenceProvider("PersistenceProvider"); Assert.assertEquals("PersistenceProvider", model.getDescriptorModel().getPersistenceUnit().getProvider()); verify(persistencePresenter).fireChangeEvent(); }
|
PersistencePresenter extends Section<ProjectScreenModel> { public void setDataSource(final String dataSource) { getPersistenceUnitModel().setJtaDataSource(dataSource); fireChangeEvent(); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testSetDataSource() { final PersistenceDescriptorEditorContent model = newPersistenceDescriptorEditorContent(); persistencePresenter.persistenceDescriptorEditorContent = model; persistencePresenter.setDataSource("DataSource"); Assert.assertEquals("DataSource", model.getDescriptorModel().getPersistenceUnit().getJtaDataSource()); verify(persistencePresenter).fireChangeEvent(); }
|
PersistencePresenter extends Section<ProjectScreenModel> { @Override public Promise<Void> save(final String comment, final Supplier<Promise<Void>> chain) { if (concurrentPersistenceXmlUpdateInfo == null) { return save(comment); } else { notificationEvent.fire(new NotificationEvent(view.getConcurrentUpdateMessage(), WARNING)); return setup(); } } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testSave() { doReturn(promises.resolve()).when(persistencePresenter).save(eq("Test comment")); persistencePresenter.save("Test comment", null).catch_(i -> { Assert.fail("Promise should've been resolved!"); return promises.resolve(); }); verify(persistencePresenter).save(eq("Test comment")); verify(persistencePresenter, never()).setup(); verify(notificationEvent, never()).fire(any()); }
@Test public void testSaveModel() { persistencePresenter.persistenceDescriptorEditorContent = newPersistenceDescriptorEditorContent(); doReturn(mock(Path.class)).when(editorService).save(any(), any(), any(), eq("Test comment")); persistencePresenter.save("Test comment").catch_(i -> { Assert.fail("Promise should've been resolved!"); return promises.resolve(); }); verify(editorService).save(any(), any(), any(), eq("Test comment")); }
|
PersistencePresenter extends Section<ProjectScreenModel> { Promise<Object> showErrorAndReject(final Object o) { return promises.catchOrExecute(o, e -> { view.showError(e.getMessage()); return promises.reject(this); }, (final String errorMessage) -> { view.showError(errorMessage); return promises.reject(this); }); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testShowErrorAndRejectWithException() { final RuntimeException testException = new RuntimeException("Test message"); doNothing().when(view).showError(any()); showErrorAndRejectFn(persistencePresenter.showErrorAndReject(testException)); }
@Test public void testShowErrorAndRejectWithRejection() { showErrorAndRejectFn(persistencePresenter.showErrorAndReject("Test message")); }
|
PersistencePresenter extends Section<ProjectScreenModel> { Promise<Boolean> validatePropertyIsNotEmpty(final List<Property> listProperty, final String errorMessage) { return promises.create((resolve, reject) -> { if (isEmpty(listProperty)) { reject.onInvoke(errorMessage); } else { resolve.onInvoke(true); } }); } @Inject PersistencePresenter(final View view,
final WorkspaceProjectContext projectContext,
final Promises promises,
final MenuItem<ProjectScreenModel> menuItem,
final Event<NotificationEvent> notificationEvent,
final Event<SettingsSectionChange<ProjectScreenModel>> settingsSectionChangeEvent,
final ManagedInstance<ObservablePath> observablePaths,
final Caller<PersistenceDescriptorEditorService> editorService,
final Caller<DataModelerService> dataModelerService,
final PropertiesListPresenter propertiesListPresenter,
final PersistableDataObjectsListPresenter persistableDataObjectsListPresenter); @Override Promise<Void> setup(final ProjectScreenModel model); @Override Promise<Object> validate(); @Override Promise<Void> save(final String comment,
final Supplier<Promise<Void>> chain); void add(final String className); void add(final Property property); void addAllProjectsPersistableDataObjects(); void setDataSource(final String dataSource); void setPersistenceUnit(final String persistenceUnit); void setPersistenceProvider(final String persistenceProvider); void addNewProperty(); void addNewPersistableDataObject(); @Override int currentHashCode(); @Override SectionView<?> getView(); }
|
@Test public void testValidatePropertyIsNotEmpty() { setupProperty("foo", "bar"); validatePropertyIsNotEmptyOnFulfilledCallback(); }
|
SettingsPresenter { @PostConstruct public void setup() { sectionManager.init(settingsSections.getList(), view.getMenuItemsContainer(), view.getContentContainer()); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testSetup() { final Section<ProjectScreenModel> section1 = newMockedSection(); final Section<ProjectScreenModel> section2 = newMockedSection(); final List<Section<ProjectScreenModel>> sections = Arrays.asList(section1, section2); doReturn(sections).when(settingsSections).getList(); doReturn(promises.resolve()).when(presenter).setupUsingCurrentSection(); presenter.setup(); verify(sectionManager).init(eq(sections), any(), any()); }
@Test public void testSetupNoMainModule() { doReturn(Optional.empty()).when(projectContext).getActiveModule(); presenter.setup(); verify(view, never()).showBusyIndicator(); }
|
SettingsPresenter { public Promise<Void> setupUsingCurrentSection() { view.init(this); if (!projectContext.getActiveModule().isPresent()) { return promises.resolve(); } view.showBusyIndicator(); projectController.canUpdateProject(projectContext.getActiveWorkspaceProject().get()).then(userCanUpdateProject -> { if (!userCanUpdateProject) { view.disableActions(); } return promises.resolve(); }); if (pathToPom != null) { pathToPom.dispose(); } concurrentPomUpdateInfo = null; pathToPom = observablePaths.get().wrap( projectContext.getActiveModule().orElseThrow(() -> new RuntimeException("Can't get active module")).getPomXMLPath()); pathToPom.onConcurrentUpdate(info -> concurrentPomUpdateInfo = info); return promises.promisify(projectScreenService, s -> { return s.load(pathToPom); }).then(model -> { this.model = model; return setupSections(model); }).then(i -> { view.hideBusyIndicator(); if (sectionManager.manages(sectionManager.getCurrentSection())) { return sectionManager.goToCurrentSection(); } else { return sectionManager.goToFirstAvailable(); } }).catch_(o -> promises.catchOrExecute(o, e -> { view.hideBusyIndicator(); return promises.reject(e); }, i -> { notificationEvent.fire(new NotificationEvent(view.getLoadErrorMessage(), ERROR)); view.hideBusyIndicator(); return promises.resolve(); })); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void setupUsingCurrentSection() { final Section<ProjectScreenModel> section = newMockedSection(); doReturn(new ArrayList<>(singletonList(section))).when(sectionManager).getSections(); doReturn(true).when(sectionManager).manages(any()); doReturn(promises.resolve()).when(sectionManager).goToCurrentSection(); doReturn(promises.resolve()).when(presenter).setupSections(any()); doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); presenter.setupUsingCurrentSection(); verify(view).init(eq(presenter)); verify(view).showBusyIndicator(); verify(view, never()).disableActions(); verify(projectScreenService).load(any()); verify(presenter).setupSections(any()); verify(sectionManager).goToCurrentSection(); verify(view).hideBusyIndicator(); verify(sectionManager, never()).goToFirstAvailable(); verify(notificationEvent, never()).fire(any()); }
|
SettingsPresenter { Promise<Object> setupSections(final ProjectScreenModel model) { final List<Section<ProjectScreenModel>> sections = new ArrayList<>(sectionManager.getSections()); return promises.all(sections, (final Section<ProjectScreenModel> section) -> setupSection(model, section)).then(i -> { if (sectionManager.isEmpty()) { return promises.reject("No sections available"); } else { return promises.resolve(); } }); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testSetupSections() { final Section<ProjectScreenModel> section1 = newMockedSection(); final Section<ProjectScreenModel> section2 = newMockedSection(); doReturn(new ArrayList<>(Arrays.asList(section1, section2))).when(sectionManager).getSections(); doReturn(promises.resolve()).when(presenter).setupSection(any(), any()); presenter.setupSections(mock(ProjectScreenModel.class)).catch_(i -> { fail("Promise should've been resolved!"); return promises.resolve(); }); verify(presenter, times(2)).setupSection(any(), any()); }
|
SettingsPresenter { Promise<Object> setupSection(final ProjectScreenModel model, final Section<ProjectScreenModel> section) { return section.setup(model) .then(i -> { sectionManager.resetDirtyIndicator(section); return promises.resolve(); }).catch_(e -> { sectionManager.remove(section); notificationEvent.fire(new NotificationEvent(getSectionSetupErrorMessage(section), WARNING)); return promises.resolve(); }); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testSetupSection() { final Section<ProjectScreenModel> section = newMockedSection(); doReturn(promises.resolve()).when(section).setup(any()); presenter.setupSection(mock(ProjectScreenModel.class), section).catch_(i -> { fail("Promise should've been resolved!"); return promises.resolve(); }); verify(section).setup(any()); verify(sectionManager).resetDirtyIndicator(section); verify(notificationEvent, never()).fire(any()); }
|
SettingsPresenter { public void showSaveModal() { projectController.canUpdateProject(projectContext.getActiveWorkspaceProject().get()).then(userCanUpdateProject -> { if (userCanUpdateProject) { sectionManager.validateAll().then(i -> { savePopUpPresenter.show(this::save); return promises.resolve(); }).catch_(o -> promises.catchOrExecute(o, e -> { view.hideBusyIndicator(); return promises.reject(e); }, (final Section<ProjectScreenModel> section) -> { view.hideBusyIndicator(); return sectionManager.goTo(section); })); } return promises.resolve(); }); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testShowSaveModal() { doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); doReturn(promises.resolve()).when(sectionManager).validateAll(); presenter.showSaveModal(); verify(savePopUpPresenter).show(any()); verify(sectionManager, never()).goTo(any()); }
@Test public void testShowSaveModalWithoutPermission() { doReturn(promises.resolve(false)).when(projectController).canUpdateProject(any()); doReturn(promises.resolve()).when(sectionManager).validateAll(); presenter.showSaveModal(); verify(savePopUpPresenter, never()).show(any()); verify(sectionManager, never()).goTo(any()); }
@Test public void testShowSaveModalWithValidationError() { doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); Section<ProjectScreenModel> section = newMockedSection(); doReturn(promises.reject(section)).when(sectionManager).validateAll(); presenter.showSaveModal(); verify(savePopUpPresenter, never()).show(any()); verify(view).hideBusyIndicator(); verify(sectionManager).goTo(section); }
|
SettingsPresenter { void save(final String comment) { promises.reduceLazilyChaining(getSavingSteps(comment), this::executeSavingStep) .catch_(o -> promises.catchOrExecute(o, promises::reject, sectionManager::goTo)); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testSave() { WorkspaceProject project = mock(WorkspaceProject.class); doReturn(project).when(projectScreenService).save(any(), any(), any(), any()); final Section<ProjectScreenModel> section1 = newMockedSection(); final Section<ProjectScreenModel> section2 = newMockedSection(); doReturn(promises.resolve()).when(section1).save(any(), any()); doReturn(promises.resolve()).when(section2).save(any(), any()); doReturn(promises.resolve()).when(sectionManager).resetAllDirtyIndicators(); doReturn(promises.resolve()).when(presenter).saveProjectScreenModel(any(), any(), any()); doReturn(new ArrayList<>(Arrays.asList(section1, section2))).when(sectionManager).getSections(); presenter.save("Test comment"); verify(section1).save(eq("Test comment"), any()); verify(section2).save(eq("Test comment"), any()); verify(presenter).saveProjectScreenModel(eq("Test comment"), eq(DeploymentMode.VALIDATED), any()); verify(presenter).displaySuccessMessage(); }
|
SettingsPresenter { Promise<Void> displaySuccessMessage() { view.hideBusyIndicator(); notificationEvent.fire(new NotificationEvent(view.getSaveSuccessMessage(), SUCCESS)); return promises.resolve(); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testDisplaySuccessMessage() { presenter.displaySuccessMessage().catch_(i -> { fail("Promise should've been resolved!"); return promises.resolve(); }); verify(view).hideBusyIndicator(); verify(notificationEvent).fire(any()); }
|
SettingsPresenter { Promise<Void> saveProjectScreenModel(final String comment, final DeploymentMode mode, final Supplier<Promise<Void>> chain) { if (concurrentPomUpdateInfo != null) { handlePomConcurrentUpdate(comment, chain); return promises.reject(sectionManager.getCurrentSection()); } return promises.promisify(projectScreenService, s -> { return s.save(pathToPom, model, comment, mode); }).then(workspaceProject -> { projectContext.updateProjectModule(workspaceProject.getMainModule()); return promises.resolve(); }).catch_(o -> promises.catchOrExecute(o, e -> { if (e instanceof GAVAlreadyExistsException) { return handlePomConcurrentUpdate(comment, chain, (GAVAlreadyExistsException) e); } else { view.hideBusyIndicator(); return promises.resolve(); } }, x -> { view.hideBusyIndicator(); return promises.reject(x); })); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testSaveProjectScreenModel() { WorkspaceProject project = mock(WorkspaceProject.class); Module module = mock(Module.class); doReturn(module).when(project).getMainModule(); doReturn(project).when(projectScreenService).save(any(), any(), any(), any()); presenter.saveProjectScreenModel("Test comment", DeploymentMode.VALIDATED, null).catch_(i -> { fail("Promise should've been resolved!"); return promises.resolve(); }); verify(projectScreenService).save(any(), any(), eq("Test comment"), eq(DeploymentMode.VALIDATED)); verify(projectContext).updateProjectModule(module); verify(presenter, never()).handlePomConcurrentUpdate(any(), any()); }
|
SettingsPresenter { void handlePomConcurrentUpdate(final String comment, final Supplier<Promise<Void>> chain) { newConcurrentUpdate(concurrentPomUpdateInfo.getPath(), concurrentPomUpdateInfo.getIdentity(), () -> forceSave(comment, chain), () -> { }, this::reset).show(); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testHandlePomConcurrentUpdate() { presenter.model = mock(ProjectScreenModel.class); doReturn(mock(POM.class)).when(presenter.model).getPOM(); presenter.handlePomConcurrentUpdate("Test comment", null, new GAVAlreadyExistsException()).then(i -> { fail("Promise should've not been resolved!"); return promises.resolve(); }); verify(view).hideBusyIndicator(); verify(conflictingRepositoriesPopup).setContent(any(), any(), any()); verify(conflictingRepositoriesPopup).show(); }
|
SettingsPresenter { void forceSave(final String comment, final Supplier<Promise<Void>> chain) { concurrentPomUpdateInfo = null; conflictingRepositoriesPopup.hide(); saveProjectScreenModel(comment, DeploymentMode.FORCED, chain).then(i -> chain.get()); } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testForceSave() { WorkspaceProject project = mock(WorkspaceProject.class); doReturn(project).when(projectScreenService).save(any(), any(), any(), any()); presenter.concurrentPomUpdateInfo = mock(ObservablePath.OnConcurrentUpdateEvent.class); presenter.forceSave("Test comment", null); assertEquals(null, presenter.concurrentPomUpdateInfo); verify(conflictingRepositoriesPopup).hide(); verify(presenter).saveProjectScreenModel(eq("Test comment"), eq(DeploymentMode.FORCED), any()); }
|
SettingsPresenter { public void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange) { if (!sectionManager.manages(settingsSectionChange.getSection())) { return; } if (settingsSectionChange.getType() == SettingsSectionChangeType.CHANGE) { sectionManager.updateDirtyIndicator(settingsSectionChange.getSection()); } } @Inject SettingsPresenter(final View view,
final Promises promises,
final Event<NotificationEvent> notificationEvent,
final @Customizable SettingsSections<ProjectScreenModel> settingsSections,
final SavePopUpPresenter savePopUpPresenter,
final Caller<ProjectScreenService> projectScreenService,
final WorkspaceProjectContext projectContext,
final ManagedInstance<ObservablePath> observablePaths,
final ConflictingRepositoriesPopup conflictingRepositoriesPopup,
final SectionManager<ProjectScreenModel> sectionManager,
final ProjectController projectController); @PostConstruct void setup(); Promise<Void> setupUsingCurrentSection(); void showSaveModal(); void onSettingsSectionChanged(@Observes final SettingsSectionChange<ProjectScreenModel> settingsSectionChange); boolean mayClose(); void reset(); View getView(); }
|
@Test public void testOnSettingsSectionChanged() { final Section<ProjectScreenModel> section = newMockedSection(); doReturn(true).when(sectionManager).manages(eq(section)); presenter.onSettingsSectionChanged(new SettingsSectionChange<>(section, SettingsSectionChangeType.CHANGE)); verify(sectionManager).updateDirtyIndicator(eq(section)); }
|
LibraryPerspective { @OnStartup public void onStartup(final PlaceRequest placeRequest) { this.refresh = Boolean.parseBoolean(placeRequest.getParameter("refresh", "true")); this.libraryPlaces.init(this); } LibraryPerspective(); @Inject LibraryPerspective(final LibraryPlaces libraryPlaces,
final Event<WorkspaceProjectContextChangeEvent> projectContextChangeEvent); @Perspective PerspectiveDefinition buildPerspective(); @OnStartup void onStartup(final PlaceRequest placeRequest); void perspectiveChangeEvent(@Observes PerspectiveChange event); @OnClose void onClose(); PanelDefinition getRootPanel(); }
|
@Test public void testLibraryPlacesIsInitialized() throws Exception { perspective.onStartup(mock(PlaceRequest.class)); verify(libraryPlaces).init(any(LibraryPerspective.class)); }
|
LibraryPerspective { public void perspectiveChangeEvent(@Observes PerspectiveChange event) { if (event.getIdentifier().equals(LibraryPlaces.LIBRARY_PERSPECTIVE)) { if (refresh) { libraryPlaces.refresh(() -> { if (getRootPanel() != null) { libraryPlaces.goToLibrary(); } }); } else { libraryPlaces.refresh(() -> { }); } } } LibraryPerspective(); @Inject LibraryPerspective(final LibraryPlaces libraryPlaces,
final Event<WorkspaceProjectContextChangeEvent> projectContextChangeEvent); @Perspective PerspectiveDefinition buildPerspective(); @OnStartup void onStartup(final PlaceRequest placeRequest); void perspectiveChangeEvent(@Observes PerspectiveChange event); @OnClose void onClose(); PanelDefinition getRootPanel(); }
|
@Test public void libraryDoesNotLoadOnPerspectiveChangeEventFromOtherPerspectives() { when(perspectiveChangeEvent.getIdentifier()).thenReturn("dora"); perspective.perspectiveChangeEvent(perspectiveChangeEvent); verify(libraryPlaces, never()).refresh(any()); }
|
LibraryPerspective { @OnClose public void onClose() { projectContextChangeEvent.fire(new WorkspaceProjectContextChangeEvent()); } LibraryPerspective(); @Inject LibraryPerspective(final LibraryPlaces libraryPlaces,
final Event<WorkspaceProjectContextChangeEvent> projectContextChangeEvent); @Perspective PerspectiveDefinition buildPerspective(); @OnStartup void onStartup(final PlaceRequest placeRequest); void perspectiveChangeEvent(@Observes PerspectiveChange event); @OnClose void onClose(); PanelDefinition getRootPanel(); }
|
@Test public void libraryResetsContextOnCloseTest() { perspective.onClose(); verify(projectContextChangeEvent).fire(new WorkspaceProjectContextChangeEvent()); }
|
ArchetypeGenerateCommand extends AbstractMavenCommand { @Override public MavenRequest buildMavenRequest() { final MavenRequest mavenRequest = MavenProjectLoader.createMavenRequest(false); mavenRequest.setGoals(GOALS); mavenRequest.setInteractive(false); return mavenRequest; } ArchetypeGenerateCommand(final String baseDirectory,
final GAV archetypeGAV,
final GAV templateGAV); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); static final List<String> GOALS; static final String ARCHETYPE_GROUP_ID; static final String ARCHETYPE_ARTIFACT_ID; static final String ARCHETYPE_VERSION; static final String TEMPLATE_GROUP_ID; static final String TEMPLATE_ARTIFACT_ID; static final String TEMPLATE_VERSION; static final String ARCHETYPE_CATALOG; static final String INTERNAL_CATALOG; }
|
@Test public void buildMavenRequestTest() { final ArchetypeGenerateCommand command = new ArchetypeGenerateCommand(BASE_DIRECTORY, createGav(), createGav()); final MavenRequest request = command.buildMavenRequest(); assertFalse(request.isInteractive()); assertThat(request.getGoals()).isEqualTo(ArchetypeGenerateCommand.GOALS); }
|
ArchetypeGenerateCommand extends AbstractMavenCommand { @Override public Properties buildUserProperties() { final Properties properties = new Properties(); properties.setProperty(ARCHETYPE_GROUP_ID, archetypeGAV.getGroupId()); properties.setProperty(ARCHETYPE_ARTIFACT_ID, archetypeGAV.getArtifactId()); properties.setProperty(ARCHETYPE_VERSION, archetypeGAV.getVersion()); properties.setProperty(TEMPLATE_GROUP_ID, templateGAV.getGroupId()); properties.setProperty(TEMPLATE_ARTIFACT_ID, templateGAV.getArtifactId()); properties.setProperty(TEMPLATE_VERSION, templateGAV.getVersion()); properties.setProperty(ARCHETYPE_CATALOG, INTERNAL_CATALOG); return properties; } ArchetypeGenerateCommand(final String baseDirectory,
final GAV archetypeGAV,
final GAV templateGAV); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); static final List<String> GOALS; static final String ARCHETYPE_GROUP_ID; static final String ARCHETYPE_ARTIFACT_ID; static final String ARCHETYPE_VERSION; static final String TEMPLATE_GROUP_ID; static final String TEMPLATE_ARTIFACT_ID; static final String TEMPLATE_VERSION; static final String ARCHETYPE_CATALOG; static final String INTERNAL_CATALOG; }
|
@Test public void buildUserPropertiesTest() { final GAV archetypeGav = createGav("archetype-group", "archetype-artifact", "archetype-version"); final GAV templateGav = createGav("template-group", "template-artifact", "template-version"); final ArchetypeGenerateCommand command = new ArchetypeGenerateCommand(BASE_DIRECTORY, archetypeGav, templateGav); final Properties properties = command.buildUserProperties(); assertThat(properties.getProperty(ArchetypeGenerateCommand.ARCHETYPE_GROUP_ID)).isEqualTo("archetype-group"); assertThat(properties.getProperty(ArchetypeGenerateCommand.ARCHETYPE_ARTIFACT_ID)).isEqualTo("archetype-artifact"); assertThat(properties.getProperty(ArchetypeGenerateCommand.ARCHETYPE_VERSION)).isEqualTo("archetype-version"); assertThat(properties.getProperty(ArchetypeGenerateCommand.TEMPLATE_GROUP_ID)).isEqualTo("template-group"); assertThat(properties.getProperty(ArchetypeGenerateCommand.TEMPLATE_ARTIFACT_ID)).isEqualTo("template-artifact"); assertThat(properties.getProperty(ArchetypeGenerateCommand.TEMPLATE_VERSION)).isEqualTo("template-version"); assertThat(properties.getProperty(ArchetypeGenerateCommand.ARCHETYPE_CATALOG)).isEqualTo(ArchetypeGenerateCommand.INTERNAL_CATALOG); }
|
ExecuteGoalsCommand extends AbstractMavenCommand { @Override public MavenRequest buildMavenRequest() { final String pomPath = baseDirectory + FileSystems.getDefault().getSeparator() + POM_XML; final MavenRequest mavenRequest = MavenProjectLoader.createMavenRequest(false); mavenRequest.setGoals(goals); mavenRequest.setPom(pomPath); return mavenRequest; } ExecuteGoalsCommand(final String baseDirectory); ExecuteGoalsCommand(final String baseDirectory,
final List<String> goals); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); static final String POM_XML; }
|
@Test public void useDefaultGoalsTest() { final ExecuteGoalsCommand command = new ExecuteGoalsCommand(BASE_DIRECTORY); final MavenRequest request = command.buildMavenRequest(); assertThat(request.getGoals()).isEqualTo(ExecuteGoalsCommand.DEFAULT_GOALS); }
@Test public void useCustomGoalsTest() { final List<String> customGoals = Collections.singletonList("compile"); final ExecuteGoalsCommand command = new ExecuteGoalsCommand(BASE_DIRECTORY, customGoals); final MavenRequest request = command.buildMavenRequest(); assertThat(request.getGoals()).isEqualTo(customGoals); }
@Test public void buildMavenRequestTest() { final String pomPath = BASE_DIRECTORY + FileSystems.getDefault().getSeparator() + ExecuteGoalsCommand.POM_XML; final ExecuteGoalsCommand command = new ExecuteGoalsCommand(BASE_DIRECTORY); final MavenRequest request = command.buildMavenRequest(); assertThat(request.getPom()).isEqualTo(pomPath); assertThat(request.getGoals()).isEqualTo(ExecuteGoalsCommand.DEFAULT_GOALS); }
|
ExecuteGoalsCommand extends AbstractMavenCommand { @Override public Properties buildUserProperties() { return new Properties(); } ExecuteGoalsCommand(final String baseDirectory); ExecuteGoalsCommand(final String baseDirectory,
final List<String> goals); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); static final String POM_XML; }
|
@Test public void buildUserPropertiesTest() { final ExecuteGoalsCommand command = new ExecuteGoalsCommand(BASE_DIRECTORY); final Properties properties = command.buildUserProperties(); assertThat(properties).isEqualTo(new Properties()); }
|
BuildProjectCommand extends AbstractMavenCommand { @Override public MavenRequest buildMavenRequest() { throw new UnsupportedOperationException(); } BuildProjectCommand(final String baseDirectory); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); @Override MavenExecutionResult execute(); }
|
@Test(expected = UnsupportedOperationException.class) public void buildMavenRequestTest() { final BuildProjectCommand command = new BuildProjectCommand(BASE_DIRECTORY); command.buildMavenRequest(); }
|
BuildProjectCommand extends AbstractMavenCommand { @Override public Properties buildUserProperties() { throw new UnsupportedOperationException(); } BuildProjectCommand(final String baseDirectory); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); @Override MavenExecutionResult execute(); }
|
@Test(expected = UnsupportedOperationException.class) public void buildUserPropertiesTest() { final BuildProjectCommand command = new BuildProjectCommand(BASE_DIRECTORY); command.buildUserProperties(); }
|
BuildProjectCommand extends AbstractMavenCommand { @Override public MavenExecutionResult execute() throws MavenEmbedderException { final MavenExecutionResult result = new DefaultMavenExecutionResult(); final MavenEmbedder mavenEmbedder = createMavenEmbedder(); final String pomPath = baseDirectory + FileSystems.getDefault().getSeparator() + POMServiceImpl.POM_XML; try { final File pomFile = new File(pomPath); mavenEmbedder.buildProjects(pomFile, false); } catch (ProjectBuildingException e) { result.addException(e); } finally { mavenEmbedder.dispose(); } return result; } BuildProjectCommand(final String baseDirectory); @Override MavenRequest buildMavenRequest(); @Override Properties buildUserProperties(); @Override MavenExecutionResult execute(); }
|
@Test public void executeSuccessTest() throws MavenEmbedderException, ProjectBuildingException { final BuildProjectCommand command = spy(new BuildProjectCommand(BASE_DIRECTORY)); final MavenEmbedder mavenEmbedder = mock(MavenEmbedder.class); doReturn(Collections.emptyList()).when(mavenEmbedder).buildProjects(any(File.class), eq(false)); doReturn(mavenEmbedder).when(command).createMavenEmbedder(); final MavenExecutionResult executionResult = command.execute(); assertFalse(executionResult.hasExceptions()); }
@Test public void executeFailedTest() throws MavenEmbedderException, ProjectBuildingException { final BuildProjectCommand command = spy(new BuildProjectCommand(BASE_DIRECTORY)); final MavenEmbedder mavenEmbedder = mock(MavenEmbedder.class); doThrow(ProjectBuildingException.class).when(mavenEmbedder).buildProjects(any(File.class), eq(false)); doReturn(mavenEmbedder).when(command).createMavenEmbedder(); final MavenExecutionResult executionResult = command.execute(); assertTrue(executionResult.hasExceptions()); }
|
ArchetypeServiceImpl implements ArchetypeService { public void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent) { final OrganizationalUnit newOU = newOrganizationalUnitEvent.getOrganizationalUnit(); if (isArchetypesOUAvailable() && !newOU.getName().equals(ArchetypeConfigStorageImpl.ARCHETYPES_SPACE_NAME)) { archetypePreferencesManager.initializeCustomPreference(newOU.getIdentifier()); } } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test public void newOrgUnitEventWhenArchetypesOrgUnitNotAvailableTest() { doReturn(Collections.emptyList()).when(ouService).getAllOrganizationalUnits(eq(false), any()); service.onNewOrganizationalUnitEvent(mock(NewOrganizationalUnitEvent.class)); verify(archetypePreferencesManager, never()).initializeCustomPreference(anyString()); }
@Test public void newOrgUnitEventWhenIsArchetypesOrgUnitTest() { doReturn(Collections.nCopies(10, mock(OrganizationalUnit.class))) .when(ouService).getAllOrganizationalUnits(eq(false), any()); final NewOrganizationalUnitEvent event = mock(NewOrganizationalUnitEvent.class); final OrganizationalUnit orgUnit = mock(OrganizationalUnit.class); doReturn(ArchetypeConfigStorageImpl.ARCHETYPES_SPACE_NAME).when(orgUnit).getName(); doReturn(orgUnit).when(event).getOrganizationalUnit(); service.onNewOrganizationalUnitEvent(event); verify(archetypePreferencesManager, never()).initializeCustomPreference(anyString()); }
@Test public void newOrgUnitEventWhenShouldInitializePreferencesTest() { doReturn(Collections.nCopies(10, mock(OrganizationalUnit.class))) .when(ouService).getAllOrganizationalUnits(eq(false), any()); final NewOrganizationalUnitEvent event = mock(NewOrganizationalUnitEvent.class); final OrganizationalUnit orgUnit = mock(OrganizationalUnit.class); doReturn("new-org-unit").when(orgUnit).getName(); doReturn(orgUnit).when(event).getOrganizationalUnit(); service.onNewOrganizationalUnitEvent(event); verify(archetypePreferencesManager).initializeCustomPreference(anyString()); }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public void add(final GAV archetypeGav) { checkNotNull("archetypeGav", archetypeGav); add(archetypeGav, copyGav(archetypeGav)); } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = IllegalArgumentException.class) public void addWhenInvalidArchetypeGavTest() { service.add(null); }
@Test public void addWhenShouldDuplicateGavForTemplateTest() { final GAV gav = createGav(); doNothing().when(service).add(any(GAV.class), any(GAV.class)); service.add(gav); verify(service).add(gav, gav); }
@Test(expected = IllegalArgumentException.class) public void addWhenInvalidTemplateGavTest() { service.add(createGav(), null); }
@Test(expected = ArchetypeAlreadyExistsException.class) public void addWhenArchetypeAlreadyExistsTest() { final GAV gav = createGav(); mockArchetypesOrgUnit(); doReturn(Collections.nCopies(10, mock(Repository.class))) .when(repositoryService).getAllRepositories(any(Space.class)); final Archetype archetype = createArchetype(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); service.add(gav); }
|
TimeZoneServiceImpl implements TimeZoneService { @Override public List<DMNSimpleTimeZone> getTimeZones() { final String[] ids = getAvailableIds(); final ArrayList<DMNSimpleTimeZone> list = new ArrayList<>(ids.length); for (final String id : ids) { final TimeZone timeZone = getTimeZone(id); final DMNSimpleTimeZone simpleTimeZone = new DMNSimpleTimeZone(); simpleTimeZone.setId(id); final double offset = toHours(timeZone.getRawOffset()); simpleTimeZone.setOffset(offset); simpleTimeZone.setOffsetString(formatOffset(offset)); list.add(simpleTimeZone); } return list; } @Override List<DMNSimpleTimeZone> getTimeZones(); }
|
@Test public void testGetTimeZones() { final TimeZone timeZone0 = mock(TimeZone.class); final TimeZone timeZone1 = mock(TimeZone.class); final String[] ids = new String[]{"0", "1"}; when(timeZone0.getRawOffset()).thenReturn(0); when(timeZone1.getRawOffset()).thenReturn(3600000); doReturn(ids).when(service).getAvailableIds(); doReturn(timeZone0).when(service).getTimeZone("0"); doReturn(timeZone1).when(service).getTimeZone("1"); final List<DMNSimpleTimeZone> simpleTimeZones = service.getTimeZones(); assertEquals(2, simpleTimeZones.size()); assertEquals(0, simpleTimeZones.get(0).getOffset(), 0.01d); assertEquals(1, simpleTimeZones.get(1).getOffset(), 0.01d); assertEquals("+00:00", simpleTimeZones.get(0).getOffsetString()); assertEquals("+01:00", simpleTimeZones.get(1).getOffsetString()); }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public void delete(final String alias) { checkNotEmpty(ALIAS_PARAM, alias); final OrganizationalUnit archetypesOU = resolveOU(); if (archetypesOU != null) { repositoryService.removeRepository(archetypesOU.getSpace(), alias); archetypeConfigStorage.deleteArchetype(alias); archetypePreferencesManager.removeArchetype(alias); archetypeListUpdatedEvent.fire(new ArchetypeListUpdatedEvent(ArchetypeListOperation.DELETE)); LOGGER.info("Archetype {} successfully deleted.", alias); } else { throw new IllegalStateException("Cannot delete an archetype when there is no archetype space available."); } } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = IllegalArgumentException.class) public void deleteWhenInvalidAliasTest() { service.delete(null); }
@Test(expected = IllegalStateException.class) public void deleteWhenArchetypesOrgUnitIsNotAvailableTest() { doReturn(null) .when(ouService).getOrganizationalUnit(ArchetypeConfigStorageImpl.ARCHETYPES_SPACE_NAME); service.delete(COMMON_ARCHETYPE_ALIAS); }
@Test public void deleteSuccessTest() { mockArchetypesOrgUnit(); service.delete(COMMON_ARCHETYPE_ALIAS); verify(repositoryService).removeRepository(any(Space.class), eq(COMMON_ARCHETYPE_ALIAS)); verify(archetypeConfigStorage).deleteArchetype(COMMON_ARCHETYPE_ALIAS); verify(archetypePreferencesManager).removeArchetype(COMMON_ARCHETYPE_ALIAS); verify(archetypeListUpdatedEvent).fire(new ArchetypeListUpdatedEvent(ArchetypeListOperation.DELETE)); }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public Repository getTemplateRepository(final String alias) { checkNotEmpty(ALIAS_PARAM, alias); final Repository repository = resolveRepository(alias); if (repository != null) { checkTemplateShouldBeValid(alias); return repository; } throw new IllegalStateException(String.format("Repository %s cannot be resolved.", alias)); } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = IllegalArgumentException.class) public void getTemplateRepositoryWhenInvalidAliasTest() { service.getTemplateRepository(null); }
@Test(expected = IllegalStateException.class) public void getTemplateRepositoryWhenInvalidStatusTest() { mockArchetypesOrgUnit(); final Archetype archetype = mock(Archetype.class); doReturn(ArchetypeStatus.INVALID).when(archetype).getStatus(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); service.getTemplateRepository(COMMON_ARCHETYPE_ALIAS); }
@Test(expected = IllegalStateException.class) public void getTemplateRepositoryWhenOrgUnitIsNotAvailableTest() { mockArchetypesOrgUnitNotAvailable(); service.getTemplateRepository(COMMON_ARCHETYPE_ALIAS); }
@Test(expected = IllegalStateException.class) public void getTemplateRepositoryWhenRepositoryIsNotAvailableTest() { mockArchetypesOrgUnit(); doReturn(null).when(repositoryService).getRepositoryFromSpace(any(Space.class), anyString()); service.getTemplateRepository(COMMON_ARCHETYPE_ALIAS); }
@Test(expected = IllegalStateException.class) public void getTemplateRepositoryWhenArchetypeIsInvalidTest() { mockArchetypesOrgUnit(); final Archetype archetype = mock(Archetype.class); doReturn(ArchetypeStatus.INVALID).when(archetype).getStatus(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); doReturn(mock(Repository.class)).when(repositoryService).getRepositoryFromSpace(any(Space.class), anyString()); service.getTemplateRepository(COMMON_ARCHETYPE_ALIAS); }
@Test public void getTemplateRepositorySuccessTest() { mockArchetypesOrgUnit(); final Archetype archetype = mock(Archetype.class); doReturn(ArchetypeStatus.VALID).when(archetype).getStatus(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); final Repository expectedRepository = mock(Repository.class); doReturn(expectedRepository).when(repositoryService).getRepositoryFromSpace(any(Space.class), eq(COMMON_ARCHETYPE_ALIAS)); final Repository repository = service.getTemplateRepository(COMMON_ARCHETYPE_ALIAS); assertSame(expectedRepository, repository); }
|
DeleteInputClauseCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler handler) { return new AbstractCanvasCommand() { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler handler) { final GridColumn<?> gridColumn = uiModel.getColumns().get(uiColumnIndex); uiModel.deleteColumn(gridColumn); updateParentInformation(); executeCanvasOperation.execute(); return CanvasCommandResultBuilder.SUCCESS; } @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler handler) { uiModel.insertColumn(uiColumnIndex, oldUiModelColumn); for (int rowIndex = 0; rowIndex < dtable.getRule().size(); rowIndex++) { uiModelMapper.fromDMNModel(rowIndex, uiColumnIndex); } updateParentInformation(); undoCanvasOperation.execute(); return CanvasCommandResultBuilder.SUCCESS; } }; } DeleteInputClauseCommand(final DecisionTable dtable,
final GridData uiModel,
final int uiColumnIndex,
final DecisionTableUIModelMapper uiModelMapper,
final org.uberfire.mvp.Command executeCanvasOperation,
final org.uberfire.mvp.Command undoCanvasOperation); void updateParentInformation(); }
|
@Test public void testCanvasCommandAllow() throws Exception { final Command<AbstractCanvasHandler, CanvasViolation> canvasCommand = command.newCanvasCommand(canvasHandler); assertEquals(CanvasCommandResultBuilder.SUCCESS, canvasCommand.allow(canvasHandler)); }
|
ArchetypeServiceImpl implements ArchetypeService { Repository createArchetypeRepository(final GAV templateGav, final String repositoryUri) { final OrganizationalUnit archetypesOU = resolveOU(); if (archetypesOU != null) { final Repository repository = repositoryService.createRepository(archetypesOU, GitRepository.SCHEME.toString(), makeRepositoryAlias(templateGav.toString()), createRepositoryConfig(repositoryUri)); cleanUpOrigin(repository); return repository; } else { throw new IllegalStateException("Cannot create an archetype when there is no archetype space available."); } } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = IllegalStateException.class) public void createArchetypeRepositoryWhenOrgUnitIsNotAvailableTest() { mockArchetypesOrgUnitNotAvailable(); service.createArchetypeRepository(eq(createTemplateGav()), anyString()); }
|
ArchetypeServiceImpl implements ArchetypeService { void throwMavenExecutionException(final List<Throwable> exceptions) { if (exceptions.isEmpty()) { throw new MavenExecutionException(); } else { final String message = exceptions.stream() .map(Throwable::getMessage) .collect(Collectors.joining(",")); throw new MavenExecutionException(message); } } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = MavenExecutionException.class) public void throwMavenExecutionExceptionEmptyTest() { service.throwMavenExecutionException(Collections.emptyList()); }
@Test(expected = MavenExecutionException.class) public void throwMavenExecutionExceptionWithContentTest() { service.throwMavenExecutionException(Collections.nCopies(10, mock(Throwable.class))); }
|
ArchetypeServiceImpl implements ArchetypeService { void executeMaven(final AbstractMavenCommand command) throws MavenEmbedderException { final MavenExecutionResult result = command.execute(); if (result.hasExceptions()) { throwMavenExecutionException(result.getExceptions()); } } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = MavenExecutionException.class) public void executeMavenWhenHasExceptionsTest() throws MavenEmbedderException { final AbstractMavenCommand command = mock(AbstractMavenCommand.class); final MavenExecutionResult result = mock(MavenExecutionResult.class); doReturn(true).when(result).hasExceptions(); doReturn(result).when(command).execute(); service.executeMaven(command); }
@Test public void executeMavenSuccessTest() throws MavenEmbedderException { final AbstractMavenCommand command = mock(AbstractMavenCommand.class); doReturn(mock(MavenExecutionResult.class)).when(command).execute(); try { service.executeMaven(command); } catch (Exception e) { fail("Should not have thrown any exception"); } }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public void validate(final String alias) { checkNotEmpty(ALIAS_PARAM, alias); final Repository repository = resolveRepository(alias); if (repository == null) { throw new IllegalStateException(String.format("Repository %s cannot be resolved.", alias)); } validateArchetype(repository); archetypePreferencesManager.addArchetype(alias); archetypeListUpdatedEvent.fire(new ArchetypeListUpdatedEvent(ArchetypeListOperation.VALIDATE)); } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = IllegalArgumentException.class) public void validateWhenInvalidAliasTest() { service.validate(null); }
@Test(expected = IllegalStateException.class) public void validateWhenOrgUnitIsNotAvailableTest() { mockArchetypesOrgUnitNotAvailable(); service.validate(COMMON_ARCHETYPE_ALIAS); }
@Test(expected = IllegalStateException.class) public void validateWhenRepositoryIsNotAvailableTest() { mockArchetypesOrgUnit(); final Archetype archetype = mock(Archetype.class); doReturn(ArchetypeStatus.VALID).when(archetype).getStatus(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); doReturn(null).when(repositoryService).getRepositoryFromSpace(any(Space.class), anyString()); service.validate(COMMON_ARCHETYPE_ALIAS); }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public PaginatedArchetypeList list(final Integer page, final Integer pageSize, final String filter) { checkNotNull("page", page); checkNotNull("pageSize", pageSize); final List<Archetype> archetypes = listFilteredArchetypes(matchNotInternalRepositories(), ArchetypeListingPredicates.matchSearchFilter(filter, ArchetypeServiceImpl::composeSearchableElement)); return finishListArchetypes(archetypes, page, pageSize); } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test(expected = IllegalArgumentException.class) public void listWhenInvalidPageTest() { service.list(null, 1, ""); }
@Test(expected = IllegalArgumentException.class) public void listWhenInvalidPageSizeTest() { service.list(0, null, ""); }
@Test(expected = IllegalArgumentException.class) public void listWhenInvalidStatusTest() { service.list(0, 1, "", null); }
@Test public void listAllTest() { mockArchetypesOrgUnit(); doReturn(Collections.nCopies(10, mock(Repository.class))) .when(repositoryService).getAllRepositories(any(Space.class)); doReturn(createArchetype()).when(archetypeConfigStorage).loadArchetype(anyString()); final PaginatedArchetypeList result = service.list(0, 0, ""); assertThat(result.getTotal()).isEqualTo(10); assertThat(result.getArchetypes()).hasSize(10); assertThat(result.getPageNumber()).isZero(); assertThat(result.getPageSize()).isZero(); }
@Test public void listAllPaginatedTest() { mockArchetypesOrgUnit(); doReturn(Collections.nCopies(13, mock(Repository.class))) .when(repositoryService).getAllRepositories(any(Space.class)); doReturn(createArchetype()).when(archetypeConfigStorage).loadArchetype(anyString()); PaginatedArchetypeList result = service.list(0, 5, ""); assertThat(result.getTotal()).isEqualTo(13); assertThat(result.getArchetypes()).hasSize(5); assertThat(result.getPageNumber()).isEqualTo(0); assertThat(result.getPageSize()).isEqualTo(5); result = service.list(1, 5, ""); assertThat(result.getTotal()).isEqualTo(13); assertThat(result.getArchetypes()).hasSize(5); assertThat(result.getPageNumber()).isEqualTo(1); assertThat(result.getPageSize()).isEqualTo(5); result = service.list(2, 5, ""); assertThat(result.getTotal()).isEqualTo(13); assertThat(result.getArchetypes()).hasSize(3); assertThat(result.getPageNumber()).isEqualTo(2); assertThat(result.getPageSize()).isEqualTo(5); }
|
ArchetypeServiceImpl implements ArchetypeService { Path unpackArchetype(final Repository repository) { try { final Path targetDirectoryPath = createTempDirectory(TEMPLATE); final File targetDirectory = new File(targetDirectoryPath.toString()); final File repositoryDirectory = resolveRepositoryDirectory(repository); cloneRepository(repositoryDirectory, targetDirectory.getAbsoluteFile()); return targetDirectoryPath; } catch (Exception e) { final String msg = String.format("Failed to unpack the repository %s", repository.getAlias()); LOGGER.error(msg, e); throw new IllegalStateException(msg); } } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test public void unpackArchetypeTest() throws GitAPIException { mockArchetypesOrgUnit(); final Path tempPath = mock(Path.class); doReturn(tempPath).when(service).createTempDirectory(anyString()); final Repository repository = mock(Repository.class); doReturn(repository).when(repositoryService).getRepositoryFromSpace(any(Space.class), anyString()); final Git git = mock(Git.class); final org.eclipse.jgit.lib.Repository gitRepository = mock(org.eclipse.jgit.lib.Repository.class); doReturn(mock(File.class)).when(gitRepository).getDirectory(); doReturn(gitRepository).when(git).getRepository(); doReturn(git).when(service).getGitFromRepository(any(Repository.class)); doNothing().when(service).cloneRepository(any(File.class), any(File.class)); final Path unpackedPath = service.unpackArchetype(repository); assertEquals(tempPath, unpackedPath); }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public Optional<Repository> getBaseKieTemplateRepository() { final Optional<Archetype> archetype = getBaseKieArchetype(); if (!archetype.isPresent()) { LOGGER.warn("The base kie project template is not registered."); return Optional.empty(); } if (archetype.get().getStatus() != ArchetypeStatus.VALID) { LOGGER.warn("The state of base kie project template is invalid."); return Optional.empty(); } final String repositoryAlias = makeRepositoryAlias(BASE_KIE_PROJECT_TEMPLATE_GAV); return Optional.ofNullable(resolveRepository(repositoryAlias)); } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test public void getBaseKieTemplateRepositoryTest() { mockArchetypesOrgUnit(); final Archetype archetype = mock(Archetype.class); doReturn(ArchetypeStatus.VALID).when(archetype).getStatus(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); final String repositoryAlias = service.makeRepositoryAlias(ArchetypeServiceImpl.BASE_KIE_PROJECT_TEMPLATE_GAV); final Repository expectedRepository = mock(Repository.class); doReturn(expectedRepository) .when(repositoryService).getRepositoryFromSpace(any(Space.class), eq(repositoryAlias)); final Optional<Repository> repository = service.getBaseKieTemplateRepository(); assertTrue(repository.isPresent()); assertThat(repository.get()).isSameAs(expectedRepository); }
@Test public void getBaseKieTemplateRepositoryWhenInvalidTest() { mockArchetypesOrgUnit(); final Archetype archetype = mock(Archetype.class); doReturn(ArchetypeStatus.INVALID).when(archetype).getStatus(); doReturn(archetype).when(archetypeConfigStorage).loadArchetype(anyString()); final Optional<Repository> repository = service.getBaseKieTemplateRepository(); assertFalse(repository.isPresent()); }
@Test public void getBaseKieTemplateRepositoryWhenNotRegisteredTest() { mockArchetypesOrgUnit(); doReturn(null).when(archetypeConfigStorage).loadArchetype(anyString()); final Optional<Repository> repository = service.getBaseKieTemplateRepository(); assertFalse(repository.isPresent()); }
|
ArchetypeServiceImpl implements ArchetypeService { @Override public Optional<Archetype> getBaseKieArchetype() { final String repositoryAlias = makeRepositoryAlias(BASE_KIE_PROJECT_TEMPLATE_GAV); final Archetype archetype = archetypeConfigStorage.loadArchetype(repositoryAlias); if (archetype == null) { LOGGER.warn("The base kie project archetype is not registered."); } return Optional.ofNullable(archetype); } ArchetypeServiceImpl(); @Inject ArchetypeServiceImpl(final @Named("ioStrategy") IOService ioService,
final RepositoryService repositoryService,
final OrganizationalUnitService ouService,
final Event<ArchetypeListUpdatedEvent> archetypeListUpdatedEvent,
final ArchetypeConfigStorage archetypeConfigStorage,
final PathUtil pathUtil,
final ArchetypePreferencesManager archetypePreferencesManager,
final KieModuleService moduleService,
final POMService pomService); void onNewOrganizationalUnitEvent(final @Observes NewOrganizationalUnitEvent newOrganizationalUnitEvent); @Override void add(final GAV archetypeGav); @Override void add(final GAV archetypeGav,
final GAV templateGav); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter); @Override PaginatedArchetypeList list(final Integer page,
final Integer pageSize,
final String filter,
final ArchetypeStatus status); @Override void delete(final String alias); @Override void validateAll(); @Override void validate(final String alias); @Override Repository getTemplateRepository(final String alias); @Override Optional<Repository> getBaseKieTemplateRepository(); @Override Optional<Archetype> getBaseKieArchetype(); }
|
@Test public void getBaseKieArchetypeTest() { service.getBaseKieArchetype(); final String repositoryAlias = service.makeRepositoryAlias(ArchetypeServiceImpl.BASE_KIE_PROJECT_TEMPLATE_GAV); verify(archetypeConfigStorage).loadArchetype(repositoryAlias); }
|
AddDecisionRuleCommand extends AbstractCanvasGraphCommand implements VetoExecutionCommand,
VetoUndoCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new AbstractGraphCommand() { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext context) { return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { dtable.getRule().add(uiRowIndex, rule); return GraphCommandResultBuilder.SUCCESS; } @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { dtable.getRule().remove(rule); return GraphCommandResultBuilder.SUCCESS; } }; } AddDecisionRuleCommand(final DecisionTable dtable,
final DecisionRule rule,
final GridData uiModel,
final GridRow uiModelRow,
final int uiRowIndex,
final DecisionTableUIModelMapper uiModelMapper,
final org.uberfire.mvp.Command canvasOperation); void updateRowNumbers(); void updateParentInformation(); }
|
@Test public void testGraphCommandAllow() throws Exception { makeCommand(0); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.allow(graphCommandExecutionContext)); }
@Test public void testGraphCommandCheck() throws Exception { makeCommand(0); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.allow(graphCommandExecutionContext)); }
@Test public void testGraphCommandExecuteConstructedDescription() { makeCommand(0); assertEquals(0, dtable.getRule().size()); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.execute(graphCommandExecutionContext)); assertEquals(1, dtable.getRule().size()); assertEquals(rule, dtable.getRule().get(0)); assertTrue(rule.getDescription() != null); assertTrue(rule.getDescription().getValue() != null); assertEquals(DecisionTableDefaultValueUtilities.RULE_DESCRIPTION, rule.getDescription().getValue()); assertEquals(dtable, rule.getParent()); }
@Test public void testGraphCommandExecuteConstructedRuleInputs() { assertEquals(0, dtable.getRule().size()); final int inputsCount = 2; for (int i = 0; i < inputsCount; i++) { dtable.getInput().add(new InputClause()); } makeCommand(0); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.execute(graphCommandExecutionContext)); assertEquals(1, dtable.getRule().size()); assertEquals(rule, dtable.getRule().get(0)); assertEquals(inputsCount, rule.getInputEntry().size()); assertEquals(0, rule.getOutputEntry().size()); for (int inputIndex = 0; inputIndex < inputsCount; inputIndex++) { assertTrue(rule.getInputEntry().get(inputIndex).getText() != null); assertEquals(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_UNARY_TEST_TEXT, rule.getInputEntry().get(inputIndex).getText().getValue()); assertEquals(rule, rule.getInputEntry().get(inputIndex).getParent()); } assertEquals(dtable, rule.getParent()); }
@Test public void testGraphCommandExecuteConstructedRuleOutputs() { assertEquals(0, dtable.getRule().size()); final int outputsCount = 2; for (int i = 0; i < outputsCount; i++) { dtable.getOutput().add(new OutputClause()); } makeCommand(0); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.execute(graphCommandExecutionContext)); assertEquals(1, dtable.getRule().size()); assertEquals(rule, dtable.getRule().get(0)); assertEquals(0, rule.getInputEntry().size()); assertEquals(outputsCount, rule.getOutputEntry().size()); for (int outputIndex = 0; outputIndex < outputsCount; outputIndex++) { assertTrue(rule.getOutputEntry().get(outputIndex).getText() != null); assertEquals(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_EXPRESSION_TEXT, rule.getOutputEntry().get(outputIndex).getText().getValue()); assertEquals(rule, rule.getOutputEntry().get(outputIndex).getParent()); } assertEquals(dtable, rule.getParent()); }
@Test public void testGraphCommandUndo() { makeCommand(0); assertEquals(0, dtable.getRule().size()); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); graphCommand.execute(graphCommandExecutionContext); assertEquals(1, dtable.getRule().size()); assertEquals(GraphCommandResultBuilder.SUCCESS, graphCommand.undo(graphCommandExecutionContext)); assertEquals(0, dtable.getRule().size()); }
@Test public void testGraphCommandExecuteInsertBelow() { final DecisionRule existingRule = new DecisionRule(); dtable.getRule().add(existingRule); makeCommand(1); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); graphCommand.execute(graphCommandExecutionContext); assertEquals(2, dtable.getRule().size()); assertEquals(existingRule, dtable.getRule().get(0)); assertEquals(rule, dtable.getRule().get(1)); }
@Test public void testGraphCommandExecuteInsertBelowThenUndo() { final DecisionRule existingRule = new DecisionRule(); dtable.getRule().add(existingRule); makeCommand(1); final Command<GraphCommandExecutionContext, RuleViolation> graphCommand = command.newGraphCommand(canvasHandler); graphCommand.execute(graphCommandExecutionContext); graphCommand.undo(graphCommandExecutionContext); assertEquals(1, dtable.getRule().size()); assertEquals(existingRule, dtable.getRule().get(0)); }
|
ArchetypePreferencesManager { public void addArchetype(final String archetype) { archetypePreferences.load(); if (addArchetypePreference(archetype)) { archetypePreferences.save(getGlobalScope()); } getOuIdentifiers().forEach(identifier -> { final PreferenceScopeResolutionStrategyInfo info = workbenchPreferenceScopeResolutionStrategies.getSpaceInfoFor(identifier); archetypePreferences.load(info); if (addArchetypePreference(archetype)) { archetypePreferences.save(info); } }); } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void addArchetypeTest() { doReturn(false).when(archetypePreferencesManager).containsArchetype(ARCHETYPE_ALIAS); archetypePreferencesManager.addArchetype(ARCHETYPE_ALIAS); verify(archetypePreferences).load(); verify(archetypePreferences).save(any(PreferenceScope.class)); verify(workbenchPreferenceScopeResolutionStrategies, times(3)).getSpaceInfoFor(anyString()); verify(archetypePreferences, times(3)).load(any(PreferenceScopeResolutionStrategyInfo.class)); verify(archetypePreferences, times(3)).save(any(PreferenceScopeResolutionStrategyInfo.class)); }
|
ArchetypePreferencesManager { public void removeArchetype(final String archetype) { archetypePreferences.load(); if (removeArchetypePreference(archetype)) { archetypePreferences.save(getGlobalScope()); } getOuIdentifiers().forEach(identifier -> { final PreferenceScopeResolutionStrategyInfo info = workbenchPreferenceScopeResolutionStrategies.getSpaceInfoFor(identifier); archetypePreferences.load(info); if (removeArchetypePreference(archetype)) { archetypePreferences.save(info); } }); } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void removeArchetypeTest() { doReturn(true).when(archetypePreferencesManager).containsArchetype(ARCHETYPE_ALIAS); archetypePreferencesManager.removeArchetype(ARCHETYPE_ALIAS); verify(archetypePreferences).load(); verify(archetypePreferences).save(any(PreferenceScope.class)); verify(workbenchPreferenceScopeResolutionStrategies, times(3)).getSpaceInfoFor(anyString()); verify(archetypePreferences, times(3)).load(any(PreferenceScopeResolutionStrategyInfo.class)); verify(archetypePreferences, times(3)).save(any(PreferenceScopeResolutionStrategyInfo.class)); }
|
ArchetypePreferencesManager { public void setDefaultArchetype(final String archetype) { archetypePreferences.load(); if (setDefaultArchetypePreference(archetype)) { archetypePreferences.save(getGlobalScope()); } getOuIdentifiers().forEach(identifier -> { final PreferenceScopeResolutionStrategyInfo info = workbenchPreferenceScopeResolutionStrategies.getSpaceInfoFor(identifier); archetypePreferences.load(info); if (setDefaultArchetypePreference(archetype)) { archetypePreferences.save(info); } }); } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void setDefaultArchetypeTest() { doReturn(true).when(archetypePreferencesManager).containsArchetype(ARCHETYPE_ALIAS); archetypePreferencesManager.setDefaultArchetype(ARCHETYPE_ALIAS); verify(archetypePreferences).load(); verify(archetypePreferences).save(any(PreferenceScope.class)); verify(workbenchPreferenceScopeResolutionStrategies, times(3)).getSpaceInfoFor(anyString()); verify(archetypePreferences, times(3)).load(any(PreferenceScopeResolutionStrategyInfo.class)); verify(archetypePreferences, times(3)).save(any(PreferenceScopeResolutionStrategyInfo.class)); verify(archetypePreferences, times(4)).setDefaultSelection(anyString()); }
|
ArchetypePreferencesManager { public void initializeCustomPreferences() { getOuIdentifiers().forEach(this::initializeCustomPreference); } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void initializeCustomPreferencesTest() { archetypePreferencesManager.initializeCustomPreferences(); verify(archetypePreferencesManager, times(3)).initializeCustomPreference(anyString()); }
|
ArchetypePreferencesManager { public void initializeCustomPreference(final String identifier) { final PreferenceScopeResolutionStrategyInfo info = workbenchPreferenceScopeResolutionStrategies.getSpaceInfoFor(identifier); archetypePreferences.load(info); archetypePreferences.save(info); } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void initializeCustomPreferenceTest() { archetypePreferencesManager.initializeCustomPreference("identifier"); verify(workbenchPreferenceScopeResolutionStrategies).getSpaceInfoFor(anyString()); verify(archetypePreferences).load(any(PreferenceScopeResolutionStrategyInfo.class)); verify(archetypePreferences).save(any(PreferenceScopeResolutionStrategyInfo.class)); }
|
ArchetypePreferencesManager { public void enableArchetype(final String archetype, final boolean isEnabled, final boolean customIncluded) { archetypePreferences.load(); if (enableArchetypePreference(archetype, isEnabled)) { archetypePreferences.save(getGlobalScope()); } if (customIncluded) { getOuIdentifiers().forEach(identifier -> { final PreferenceScopeResolutionStrategyInfo info = workbenchPreferenceScopeResolutionStrategies.getSpaceInfoFor(identifier); archetypePreferences.load(info); if (enableArchetypePreference(archetype, isEnabled)) { archetypePreferences.save(info); } }); } } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void enableArchetypeTest() { doReturn(true).when(archetypePreferencesManager).containsArchetype(ARCHETYPE_ALIAS); archetypePreferencesManager.enableArchetype(ARCHETYPE_ALIAS, true, true); verify(archetypePreferences).load(); verify(archetypePreferences).save(any(PreferenceScope.class)); verify(workbenchPreferenceScopeResolutionStrategies, times(3)).getSpaceInfoFor(anyString()); verify(archetypePreferences, times(3)).load(any(PreferenceScopeResolutionStrategyInfo.class)); verify(archetypePreferences, times(3)).save(any(PreferenceScopeResolutionStrategyInfo.class)); }
|
ArchetypePreferencesManager { boolean containsArchetype(final String archetype) { return archetypePreferences.getArchetypeSelectionMap().containsKey(archetype); } ArchetypePreferencesManager(); @Inject ArchetypePreferencesManager(final PreferenceScopeFactory scopeFactory,
final WorkbenchPreferenceScopeResolutionStrategies workbenchPreferenceScopeResolutionStrategies,
final ArchetypePreferences archetypePreferences,
final OrganizationalUnitService ouService); void addArchetype(final String archetype); void removeArchetype(final String archetype); void setDefaultArchetype(final String archetype); void initializeCustomPreferences(); void initializeCustomPreference(final String identifier); void enableArchetype(final String archetype,
final boolean isEnabled,
final boolean customIncluded); }
|
@Test public void containsArchetypeTrueTest() { final Map<String, Boolean> archetypeSelectionMap = new HashMap<>(); archetypeSelectionMap.put("archetype", true); doReturn(archetypeSelectionMap).when(archetypePreferences).getArchetypeSelectionMap(); assertTrue(archetypePreferencesManager.containsArchetype("archetype")); }
@Test public void containsArchetypeFalseTest() { final Map<String, Boolean> archetypeSelectionMap = new HashMap<>(); archetypeSelectionMap.put("archetype", true); doReturn(archetypeSelectionMap).when(archetypePreferences).getArchetypeSelectionMap(); assertFalse(archetypePreferencesManager.containsArchetype("other")); }
|
ArchetypeManagementScreenPresenter { @WorkbenchPartView public View getView() { return view; } @Inject ArchetypeManagementScreenPresenter(final View view,
final TranslationService ts,
final Event<NotificationEvent> notificationEvent,
final ArchetypeTablePresenter archetypeTablePresenter,
final Promises promises); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView View getView(); @OnOpen void onOpen(); @OnClose void onClose(); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); void notifyListUpdated(final ArchetypeListOperation operation); static final String IDENTIFIER; }
|
@Test public void getViewTest() { assertEquals(view, presenter.getView()); }
|
ArchetypeManagementScreenPresenter { @WorkbenchPartTitle public String getTitle() { return ts.getTranslation(ArchetypeManagementConstants.ArchetypeManagement_ArchetypeManagementPerspectiveName); } @Inject ArchetypeManagementScreenPresenter(final View view,
final TranslationService ts,
final Event<NotificationEvent> notificationEvent,
final ArchetypeTablePresenter archetypeTablePresenter,
final Promises promises); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView View getView(); @OnOpen void onOpen(); @OnClose void onClose(); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); void notifyListUpdated(final ArchetypeListOperation operation); static final String IDENTIFIER; }
|
@Test public void getTitleTest() { final String title = "title"; doReturn(title).when(ts) .getTranslation(ArchetypeManagementConstants.ArchetypeManagement_ArchetypeManagementPerspectiveName); assertEquals(title, presenter.getTitle()); }
|
ArchetypeManagementScreenPresenter { @OnOpen public void onOpen() { loadScreen(); } @Inject ArchetypeManagementScreenPresenter(final View view,
final TranslationService ts,
final Event<NotificationEvent> notificationEvent,
final ArchetypeTablePresenter archetypeTablePresenter,
final Promises promises); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView View getView(); @OnOpen void onOpen(); @OnClose void onClose(); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); void notifyListUpdated(final ArchetypeListOperation operation); static final String IDENTIFIER; }
|
@Test public void onOpenTest() { doReturn(promises.resolve()).when(archetypeTablePresenter).setup(eq(false), any()); presenter.onOpen(); verify(archetypeTablePresenter).setup(eq(false), any()); }
|
ArchetypeManagementScreenPresenter { @OnClose public void onClose() { archetypeTablePresenter.reset(); } @Inject ArchetypeManagementScreenPresenter(final View view,
final TranslationService ts,
final Event<NotificationEvent> notificationEvent,
final ArchetypeTablePresenter archetypeTablePresenter,
final Promises promises); @WorkbenchPartTitle String getTitle(); @WorkbenchPartView View getView(); @OnOpen void onOpen(); @OnClose void onClose(); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); void notifyListUpdated(final ArchetypeListOperation operation); static final String IDENTIFIER; }
|
@Test public void onCloseTest() { presenter.onClose(); verify(archetypeTablePresenter).reset(); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event) { if (isSetup()) { loadList(false); } } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void onArchetypeListUpdatedEventWhenIsNotSetupTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("setup")).set(false); presenter.onArchetypeListUpdatedEvent(new ArchetypeListUpdatedEvent(ArchetypeListOperation.ADD)); verify(archetypeService, never()).list(any(), any(), any()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { @Override public void showBusyIndicator(final String message) { busyIndicatorView.showBusyIndicator(message); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void showBusyIndicatorTest() { final String msg = "Loading"; presenter.showBusyIndicator(msg); verify(busyIndicatorView).showBusyIndicator(msg); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { @Override public void hideBusyIndicator() { busyIndicatorView.hideBusyIndicator(); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void hideBusyIndicatorTest() { presenter.hideBusyIndicator(); verify(busyIndicatorView).hideBusyIndicator(); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { @Override public boolean isEmpty() { return !isSetup() || archetypeListPresenter.getObjectsList().isEmpty(); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void isEmptyShouldBeTrueWhenIsNotSetupTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("setup")).set(false); assertTrue(presenter.isEmpty()); }
@Test public void isEmptyWhenTrueTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("setup")).set(true); doReturn(Collections.emptyList()).when(archetypeListPresenter).getObjectsList(); assertTrue(presenter.isEmpty()); }
@Test public void isEmptyWhenFalseTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("setup")).set(true); doReturn(Collections.singletonList(mock(ArchetypeItem.class))).when(archetypeListPresenter).getObjectsList(); assertFalse(presenter.isEmpty()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { @Override public void reset() { setup = false; } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void resetTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("setup")).set(true); presenter.reset(); assertFalse(presenter.isSetup()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void setCurrentPage(final int currentPage) { if (currentPage <= totalPages && currentPage > 0) { this.currentPage = currentPage; updateList(); } } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void setCurrentPageTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("totalPages")).set(10); doNothing().when(presenter).updateList(); presenter.setCurrentPage(5); assertEquals(5, presenter.currentPage); verify(presenter).updateList(); }
@Test public void setCurrentPageOutRangeTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("currentPage")).set(10); new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("totalPages")).set(10); presenter.setCurrentPage(50); assertEquals(10, presenter.currentPage); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void goToPreviousPage() { if (currentPage - 1 >= 1) { currentPage--; updateList(); } } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void goToPreviousPageTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("currentPage")).set(5); new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("totalPages")).set(10); doNothing().when(presenter).updateList(); presenter.goToPreviousPage(); assertEquals(4, presenter.currentPage); verify(presenter).updateList(); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void goToNextPage() { if (currentPage + 1 <= totalPages) { currentPage++; updateList(); } } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void goToNextPageTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("currentPage")).set(1); new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("totalPages")).set(10); doNothing().when(presenter).updateList(); presenter.goToNextPage(); assertEquals(2, presenter.currentPage); verify(presenter).updateList(); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void goToFirstPage() { currentPage = 1; updateList(); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void goToFirstPageTest() { doNothing().when(presenter).updateList(); presenter.goToFirstPage(); assertEquals(1, presenter.currentPage); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void goToLastPage() { currentPage = totalPages; updateList(); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void goToLastPageTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("totalPages")).set(10); doNothing().when(presenter).updateList(); presenter.goToLastPage(); assertEquals(10, presenter.currentPage); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void search(final String searchText) { searchFilter = searchText; currentPage = 1; updateList(); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void searchTest() { final String searchFilter = "keyword"; doNothing().when(presenter).updateList(); presenter.search(searchFilter); assertEquals(searchFilter, presenter.searchFilter); assertEquals(1, presenter.currentPage); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public List<String> getIncluded() { return getSelectionMap() .entrySet() .stream() .filter(Map.Entry::getValue) .map(Map.Entry::getKey) .collect(Collectors.toList()); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void getIncludedWhenEmptyTest() { doReturn(Collections.emptyMap()).when(archetypePreferences).getArchetypeSelectionMap(); final List<String> result = presenter.getIncluded(); assertEquals(0, result.size()); }
@Test public void getIncludedWhenAllEnabledTest() { final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("archetype 1", true); selectionMap.put("archetype 2", true); selectionMap.put("archetype 3", true); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); final List<String> result = presenter.getIncluded(); assertEquals(3, result.size()); }
@Test public void getIncludedWhenAllDisabledTest() { final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("archetype 1", false); selectionMap.put("archetype 2", false); selectionMap.put("archetype 3", false); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); final List<String> result = presenter.getIncluded(); assertEquals(0, result.size()); }
@Test public void getIncludedMixedTest() { final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("archetype 1", true); selectionMap.put("archetype 2", false); selectionMap.put("archetype 3", true); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); final List<String> result = presenter.getIncluded(); assertEquals(2, result.size()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void setSelected(final ArchetypeItem archetypeItem, final boolean isSelected) { final Map<String, Boolean> selectionMap = getSelectionMap(); if (selectionMap.containsKey(archetypeItem.getArchetype().getAlias())) { getSelectionMap().put(archetypeItem.getArchetype().getAlias(), isSelected); updateSelectionCounter(); runOnChangedCallback(); } } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void setSelectedWhenKeyIsNotPresentTest() { final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("archetype 1", true); selectionMap.put("archetype 2", false); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); presenter.setSelected(createArchetypeItem(), true); verify(view, never()).setSelectionCounter(anyString()); }
@Test public void setSelectedWhenKeyIsPresentTest() throws NoSuchFieldException { final Runnable callback = () -> { }; new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("onChangedCallback")) .set(callback); final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("myArchetype", true); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); presenter.setSelected(createArchetypeItem(), true); verify(view).setSelectionCounter(anyString()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public void updateSelectionCounter() { view.setSelectionCounter(ts.format(ArchetypeManagementConstants.ArchetypeManagement_SelectionCounter, getIncluded().size(), getSelectionMap().size())); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void updateSelectionCounterTest() { doReturn(Collections.nCopies(1, "archetype")).when(presenter).getIncluded(); final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("archetype 1", true); selectionMap.put("archetype 2", false); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); presenter.updateSelectionCounter(); verify(view).setSelectionCounter(anyString()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { protected ParameterizedCommand<ArchetypePreferences> loadPreferencesSuccessCallback(final PaginatedArchetypeList paginatedList, final Promise.PromiseExecutorCallbackFn.ResolveCallbackFn<Void> resolve) { return preference -> { finishLoadList(paginatedList); resolve.onInvoke(promises.resolve()); }; } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void loadPreferencesSuccessCallbackTest() { final PaginatedArchetypeList paginatedArchetypeList = mock(PaginatedArchetypeList.class); doNothing().when(presenter).finishLoadList(paginatedArchetypeList); presenter.loadPreferencesSuccessCallback(paginatedArchetypeList, mock(Promise.PromiseExecutorCallbackFn.ResolveCallbackFn.class)) .execute(archetypePreferences); verify(presenter).finishLoadList(paginatedArchetypeList); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { protected ParameterizedCommand<Throwable> loadPreferencesErrorCallback(final Promise.PromiseExecutorCallbackFn.RejectCallbackFn reject) { return error -> { hideBusyIndicator(); reject.onInvoke(error); }; } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void loadPreferencesErrorCallbackTest() { presenter.loadPreferencesErrorCallback(mock(Promise.PromiseExecutorCallbackFn.RejectCallbackFn.class)) .execute(mock(Throwable.class)); verify(busyIndicatorView).hideBusyIndicator(); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { protected void updateList() { loadList(true); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void updateListTest() { doReturn(promises.resolve()).when(presenter).loadList(true); presenter.updateList(); verify(presenter).loadList(true); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { protected void finishLoadList(final PaginatedArchetypeList paginatedList) { final List<ArchetypeItem> archetypeItems = paginatedList.getArchetypes() .stream() .map(archetype -> new ArchetypeItem(archetype, getSelectionMap().get(archetype.getAlias()), archetype.getAlias().equals(archetypePreferences.getDefaultSelection()))) .collect(Collectors.toList()); archetypeListPresenter.setup(view.getTableBody(), archetypeItems, (property, presenter) -> presenter.setup(property, this)); updateSelectionCounter(); hideBusyIndicator(); view.show(true); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void finishLoadListTest() { final List<Archetype> archetypes = new ArrayList<>(); archetypes.add(createArchetypeWithAlias("archetype 1")); archetypes.add(createArchetypeWithAlias("archetype 2")); archetypes.add(createArchetypeWithAlias("archetype 3")); final Map<String, Boolean> selectionMap = new HashMap<>(); selectionMap.put("archetype 1", true); selectionMap.put("archetype 2", true); selectionMap.put("archetype 3", true); final PaginatedArchetypeList paginatedArchetypeList = new PaginatedArchetypeList(archetypes, 0, 10, 3); doReturn(selectionMap).when(archetypePreferences).getArchetypeSelectionMap(); doReturn("archetype 1").when(archetypePreferences).getDefaultSelection(); presenter.finishLoadList(paginatedArchetypeList); verify(archetypeListPresenter).setup(any(), any(), any()); verify(view).setSelectionCounter(anyString()); verify(busyIndicatorView).hideBusyIndicator(); verify(view).show(true); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { @Override public ArchetypePreferences getPreferences() { return archetypePreferences; } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void getPreferencesTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("archetypePreferences")) .set(archetypePreferences); assertEquals(archetypePreferences, presenter.getPreferences()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { public View getView() { return view; } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void getViewTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("view")) .set(view); assertEquals(view, presenter.getView()); }
|
AbstractArchetypeTablePresenter implements ArchetypeTablePresenter,
HasBusyIndicator { void setupCounters(final int totalArchetypes) { this.currentPage = Math.max(1, this.currentPage); if (totalArchetypes < (currentPage - 1) * PAGE_SIZE + 1) { currentPage = totalArchetypes / PAGE_SIZE; } final int offset = (currentPage - 1) * PAGE_SIZE; final int fromCount = totalArchetypes > 0 ? offset + 1 : offset; final int toCount = resolveCounter(totalArchetypes, offset + PAGE_SIZE); final int totalCount = resolveCounter(totalArchetypes, 0); final String indicatorText = ts.format(ArchetypeManagementConstants.ArchetypeManagement_ItemCountIndicatorText, fromCount, toCount, totalCount); view.setPageIndicator(indicatorText); totalPages = (int) Math.ceil(totalArchetypes / (float) PAGE_SIZE); final String totalText = ts.format(ArchetypeManagementConstants.ArchetypeManagement_OfN, Math.max(totalPages, 1)); view.setTotalPages(totalText); view.setCurrentPage(currentPage); checkPaginationButtons(); } AbstractArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises); void onArchetypeListUpdatedEvent(@Observes final ArchetypeListUpdatedEvent event); abstract Promise<Void> makeDefaultValue(String alias,
boolean updateList); abstract Promise<Void> loadPreferences(PaginatedArchetypeList paginatedList); abstract boolean canMakeChanges(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); @Override boolean isSetup(); @Override ArchetypePreferences getPreferences(); @Override boolean isEmpty(); @Override void reset(); @Override Promise<Void> setup(final boolean isRefresh,
final Runnable onChangedCallback); View getView(); void setCurrentPage(final int currentPage); void goToPreviousPage(); void goToNextPage(); void goToFirstPage(); void goToLastPage(); void search(final String searchText); void addArchetype(); List<String> getIncluded(); boolean isShowIncludeColumn(); boolean isShowStatusColumn(); boolean isShowDeleteAction(); boolean isShowValidateAction(); void setSelected(final ArchetypeItem archetypeItem,
final boolean isSelected); void updateSelectionCounter(); Promise<Void> savePreferences(final PreferenceScope scope,
final boolean updateList); Promise<Void> savePreferences(final PreferenceScopeResolutionStrategyInfo strategyInfo,
final boolean updateList); }
|
@Test public void setupCountersWhenInLastPageListTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("currentPage")) .set(10); presenter.setupCounters(100); assertEquals(10, presenter.currentPage); assertEquals(10, presenter.totalPages); verify(view).enablePreviousButton(true); verify(view).enableNextButton(false); verify(view).enableFirstButton(true); verify(view).enableLastButton(false); }
@Test public void setupCountersWhenInFirstPageListTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("currentPage")) .set(1); presenter.setupCounters(100); assertEquals(1, presenter.currentPage); assertEquals(10, presenter.totalPages); verify(view).enablePreviousButton(false); verify(view).enableNextButton(true); verify(view).enableFirstButton(false); verify(view).enableLastButton(true); }
@Test public void setupCountersWhenInMiddlePageListTest() throws NoSuchFieldException { new FieldSetter(presenter, AbstractArchetypeTablePresenter.class.getDeclaredField("currentPage")) .set(5); presenter.setupCounters(100); assertEquals(5, presenter.currentPage); assertEquals(10, presenter.totalPages); verify(view).enablePreviousButton(true); verify(view).enableNextButton(true); verify(view).enableFirstButton(true); verify(view).enableLastButton(true); }
|
GlobalArchetypeTablePresenter extends AbstractArchetypeTablePresenter { @Override public Promise<Void> loadPreferences(final PaginatedArchetypeList paginatedList) { return promises.create( (resolve, reject) -> archetypePreferences.load(loadPreferencesSuccessCallback(paginatedList, resolve), loadPreferencesErrorCallback(reject))); } @Inject GlobalArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises,
final AuthorizationManager authorizationManager,
final User user); @Override Promise<Void> loadPreferences(final PaginatedArchetypeList paginatedList); @Override Promise<Void> makeDefaultValue(final String alias,
final boolean updateList); @Override ArchetypeTableConfiguration initConfiguration(); @Override boolean canMakeChanges(); @Override Promise<Void> savePreferences(final boolean updateList); }
|
@Test public void loadPreferencesTest() { presenter.loadPreferences(any(PaginatedArchetypeList.class)).catch_(i -> { Assert.fail("Promise should've been resolved!"); return promises.resolve(); }); verify(archetypePreferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); }
|
GlobalArchetypeTablePresenter extends AbstractArchetypeTablePresenter { @Override public boolean canMakeChanges() { final ResourceRef resourceRef = new ResourceRef(ArchetypeManagementPerspective.IDENTIFIER, ActivityResourceType.PERSPECTIVE); return authorizationManager.authorize(resourceRef, user); } @Inject GlobalArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises,
final AuthorizationManager authorizationManager,
final User user); @Override Promise<Void> loadPreferences(final PaginatedArchetypeList paginatedList); @Override Promise<Void> makeDefaultValue(final String alias,
final boolean updateList); @Override ArchetypeTableConfiguration initConfiguration(); @Override boolean canMakeChanges(); @Override Promise<Void> savePreferences(final boolean updateList); }
|
@Test public void canMakeChangesWhenTrueTest() { doReturn(true).when(authorizationManager).authorize(any(ResourceRef.class), any(User.class)); final boolean result = presenter.canMakeChanges(); assertTrue(result); verify(authorizationManager).authorize(any(ResourceRef.class), any(User.class)); }
@Test public void canMakeChangesWhenFalseTest() { doReturn(false).when(authorizationManager).authorize(any(ResourceRef.class), any(User.class)); final boolean result = presenter.canMakeChanges(); assertFalse(result); verify(authorizationManager).authorize(any(ResourceRef.class), any(User.class)); }
|
GlobalArchetypeTablePresenter extends AbstractArchetypeTablePresenter { @Override public ArchetypeTableConfiguration initConfiguration() { return new ArchetypeTableConfiguration.Builder() .withAddAction() .withDeleteAction() .withValidateAction() .withStatusColumn() .build(); } @Inject GlobalArchetypeTablePresenter(final View view,
final ArchetypeListPresenter archetypeListPresenter,
final BusyIndicatorView busyIndicatorView,
final TranslationService ts,
final AddArchetypeModalPresenter addArchetypeModalPresenter,
final ArchetypePreferences archetypePreferences,
final Caller<ArchetypeService> archetypeService,
final PreferenceScopeFactory preferenceScopeFactory,
final Promises promises,
final AuthorizationManager authorizationManager,
final User user); @Override Promise<Void> loadPreferences(final PaginatedArchetypeList paginatedList); @Override Promise<Void> makeDefaultValue(final String alias,
final boolean updateList); @Override ArchetypeTableConfiguration initConfiguration(); @Override boolean canMakeChanges(); @Override Promise<Void> savePreferences(final boolean updateList); }
|
@Test public void initConfigurationTest() { final ArchetypeTableConfiguration expectedConfig = new ArchetypeTableConfiguration.Builder() .withAddAction() .withDeleteAction() .withValidateAction() .withStatusColumn() .build(); assertEquals(expectedConfig, presenter.initConfiguration()); }
|
ArchetypeItemPresenter extends ListItemPresenter<ArchetypeItem, AbstractArchetypeTablePresenter, ArchetypeItemPresenter.View> implements HasBusyIndicator { @Override public ArchetypeItemPresenter setup(final ArchetypeItem archetypeItem, final AbstractArchetypeTablePresenter parentPresenter) { final Archetype archetype = archetypeItem.getArchetype(); this.archetypeItem = archetypeItem; this.parentPresenter = parentPresenter; view.init(this); view.setIncluded(archetypeItem.isSelected()); view.setGroupId(archetype.getGav().getGroupId()); view.setArtifactId(archetype.getGav().getArtifactId()); view.setVersion(archetype.getGav().getVersion()); view.setCreatedDate(DATE_FORMAT.format(archetype.getCreatedDate())); view.showInclude(parentPresenter.isShowIncludeColumn()); view.showStatus(parentPresenter.isShowStatusColumn()); view.showDeleteAction(parentPresenter.isShowDeleteAction()); view.showValidateAction(parentPresenter.isShowValidateAction()); view.showDefaultBadge(archetypeItem.isDefaultValue()); view.enableIncludeCheckbox(isValid()); view.enableSetDefault(isValid()); if (parentPresenter.isShowDeleteAction()) { view.setDeleteCommand(createDeleteCommand(archetypeItem)); } if (archetypeItem.isDefaultValue()) { view.setDefaultBadgeTooltip(ts.getTranslation(ArchetypeManagementConstants.ArchetypeManagement_DefaultMessage)); } resolveStatus(archetype); return this; } @Inject ArchetypeItemPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @Override ArchetypeItemPresenter setup(final ArchetypeItem archetypeItem,
final AbstractArchetypeTablePresenter parentPresenter); @Override ArchetypeItem getObject(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); void setIncluded(final boolean isIncluded); void makeDefault(); void validate(); }
|
@Test public void setupWhenInvalidStatusTest() { final Archetype archetype = createArchetypeWithStatus(ArchetypeStatus.INVALID); final ArchetypeItem archetypeItem = new ArchetypeItem(archetype, true, true); presenter.setup(archetypeItem, tablePresenter); verify(view).enableIncludeCheckbox(false); verify(view).enableSetDefault(false); verify(view).showValidStatus(false); verify(view).showInvalidStatus(true); verify(view).setInvalidTooltip(anyString()); verify(view, never()).setValidTooltip(anyString()); }
@Test public void setupWhenValidStatusTest() { presenter.setup(createArchetypeItem(), tablePresenter); verify(view).enableIncludeCheckbox(true); verify(view).enableSetDefault(true); verify(view).showValidStatus(true); verify(view).showInvalidStatus(false); verify(view, never()).setInvalidTooltip(anyString()); verify(view).setValidTooltip(anyString()); }
@Test public void setupWhenShowIncludeTest() { doReturn(true).when(tablePresenter).isShowIncludeColumn(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showInclude(true); }
@Test public void setupWhenHideIncludeTest() { doReturn(false).when(tablePresenter).isShowIncludeColumn(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showInclude(false); }
@Test public void setupWhenShowStatusColumnTest() { doReturn(true).when(tablePresenter).isShowStatusColumn(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showStatus(true); }
@Test public void setupWhenHideStatusColumnTest() { doReturn(false).when(tablePresenter).isShowStatusColumn(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showStatus(false); }
@Test public void setupWhenShowDeleteActionTest() { doReturn(true).when(tablePresenter).isShowDeleteAction(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showDeleteAction(true); verify(view).setDeleteCommand(any()); }
@Test public void setupWhenHideDeleteActionTest() { doReturn(false).when(tablePresenter).isShowDeleteAction(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showDeleteAction(false); verify(view, never()).setDeleteCommand(any()); }
@Test public void setupWhenShowValidateActionTest() { doReturn(true).when(tablePresenter).isShowValidateAction(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showValidateAction(true); }
@Test public void setupWhenHideValidateActionTest() { doReturn(false).when(tablePresenter).isShowValidateAction(); presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showValidateAction(false); }
@Test public void setupWhenShowDefaultBadgeTest() { presenter.setup(createArchetypeItem(), tablePresenter); verify(view).showDefaultBadge(true); }
@Test public void setupWhenHideDefaultBadgeTest() { final Archetype archetype = createArchetypeWithStatus(ArchetypeStatus.VALID); final ArchetypeItem archetypeItem = new ArchetypeItem(archetype, true, false); presenter.setup(archetypeItem, tablePresenter); verify(view).showDefaultBadge(false); }
@Test public void setupWhenEnableIncludeTest() { presenter.setup(createArchetypeItem(), tablePresenter); verify(view).enableIncludeCheckbox(true); }
@Test public void setupWhenDisableIncludeTest() { final Archetype archetype = createArchetypeWithStatus(ArchetypeStatus.INVALID); final ArchetypeItem archetypeItem = new ArchetypeItem(archetype, true, true); presenter.setup(archetypeItem, tablePresenter); verify(view).enableIncludeCheckbox(false); }
@Test public void setupWhenEnableSetDefaultTest() { presenter.setup(createArchetypeItem(), tablePresenter); verify(view).enableSetDefault(true); }
@Test public void setupWhenDisableSetDefaultTest() { final Archetype archetype = createArchetypeWithStatus(ArchetypeStatus.INVALID); final ArchetypeItem archetypeItem = new ArchetypeItem(archetype, true, true); presenter.setup(archetypeItem, tablePresenter); verify(view).enableSetDefault(false); }
|
ArchetypeItemPresenter extends ListItemPresenter<ArchetypeItem, AbstractArchetypeTablePresenter, ArchetypeItemPresenter.View> implements HasBusyIndicator { @Override public ArchetypeItem getObject() { return archetypeItem; } @Inject ArchetypeItemPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @Override ArchetypeItemPresenter setup(final ArchetypeItem archetypeItem,
final AbstractArchetypeTablePresenter parentPresenter); @Override ArchetypeItem getObject(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); void setIncluded(final boolean isIncluded); void makeDefault(); void validate(); }
|
@Test public void getObjectTest() { final ArchetypeItem archetypeItem = createArchetypeItem(); presenter.setup(archetypeItem, tablePresenter); assertEquals(archetypeItem, presenter.getObject()); }
|
ArchetypeItemPresenter extends ListItemPresenter<ArchetypeItem, AbstractArchetypeTablePresenter, ArchetypeItemPresenter.View> implements HasBusyIndicator { @Override public void showBusyIndicator(final String message) { busyIndicatorView.showBusyIndicator(message); } @Inject ArchetypeItemPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @Override ArchetypeItemPresenter setup(final ArchetypeItem archetypeItem,
final AbstractArchetypeTablePresenter parentPresenter); @Override ArchetypeItem getObject(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); void setIncluded(final boolean isIncluded); void makeDefault(); void validate(); }
|
@Test public void showBusyIndicatorTest() { final String msg = "Loading"; presenter.showBusyIndicator(msg); verify(busyIndicatorView).showBusyIndicator(msg); }
|
ArchetypeItemPresenter extends ListItemPresenter<ArchetypeItem, AbstractArchetypeTablePresenter, ArchetypeItemPresenter.View> implements HasBusyIndicator { @Override public void hideBusyIndicator() { busyIndicatorView.hideBusyIndicator(); } @Inject ArchetypeItemPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @Override ArchetypeItemPresenter setup(final ArchetypeItem archetypeItem,
final AbstractArchetypeTablePresenter parentPresenter); @Override ArchetypeItem getObject(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); void setIncluded(final boolean isIncluded); void makeDefault(); void validate(); }
|
@Test public void hideBusyIndicatorTest() { presenter.hideBusyIndicator(); verify(busyIndicatorView).hideBusyIndicator(); }
|
ArchetypeManagementPerspective { @Perspective public PerspectiveDefinition buildPerspective() { final PerspectiveDefinition perspective = new PerspectiveDefinitionImpl(StaticWorkbenchPanelPresenter.class.getName()); perspective.setName(NAME); perspective.getRoot() .addPart(new PartDefinitionImpl(new DefaultPlaceRequest(ArchetypeManagementScreenPresenter.IDENTIFIER))); return perspective; } @Perspective PerspectiveDefinition buildPerspective(); static final String IDENTIFIER; static final String NAME; }
|
@Test public void buildPerspectiveTest() { final PerspectiveDefinition perspectiveDefinition = perspective.buildPerspective(); assertEquals(ArchetypeManagementPerspective.NAME, perspectiveDefinition.getName()); assertEquals(1, perspectiveDefinition.getRoot().getParts().size()); assertTrue(perspectiveDefinition.getRoot().getParts().contains( new PartDefinitionImpl(new DefaultPlaceRequest(ArchetypeManagementScreenPresenter.IDENTIFIER)))); }
|
AddArchetypeModalPresenter implements HasBusyIndicator { @PostConstruct public void postConstruct() { view.init(this); } @Inject AddArchetypeModalPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @PostConstruct void postConstruct(); void show(); void hide(); void add(); void cancel(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); }
|
@Test public void postConstructTest() { presenter.postConstruct(); verify(view).init(presenter); }
|
AddArchetypeModalPresenter implements HasBusyIndicator { public void show() { view.resetAll(); view.show(); } @Inject AddArchetypeModalPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @PostConstruct void postConstruct(); void show(); void hide(); void add(); void cancel(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); }
|
@Test public void showTest() { presenter.show(); verify(view).resetAll(); verify(view).show(); }
|
AddArchetypeModalPresenter implements HasBusyIndicator { public void hide() { view.hide(); } @Inject AddArchetypeModalPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @PostConstruct void postConstruct(); void show(); void hide(); void add(); void cancel(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); }
|
@Test public void hideTest() { presenter.hide(); verify(view).hide(); }
|
AddArchetypeModalPresenter implements HasBusyIndicator { public void cancel() { hide(); } @Inject AddArchetypeModalPresenter(final View view,
final TranslationService ts,
final Caller<ArchetypeService> archetypeService,
final BusyIndicatorView busyIndicatorView); @PostConstruct void postConstruct(); void show(); void hide(); void add(); void cancel(); @Override void showBusyIndicator(final String message); @Override void hideBusyIndicator(); }
|
@Test public void cancelTest() { presenter.cancel(); verify(view).hide(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.