src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DefaultRemoteExecutor implements RemoteExecutor { @Override public CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath) { return internalBuild(projectPath, mavenRepoPath, settingsXmlPath, Boolean.FALSE, MavenCLIArgs.COMPILE); } DefaultRemoteExecutor(ExecutorService executorService); @Override CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath); @Override CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath, Boolean skipPrjDependenciesCreationList); @Override CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath); @Override CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath,
Boolean skipPrjDependenciesCreationList); @Override CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args); @Override CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args,
Boolean skipPrjDependenciesCreationList); }
|
@Test public void buildNonExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.build(tmpRoot.toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile()); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isFalse(); }
@Test public void buildAndSkipDepsNonExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.build(tmpRoot.toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile(), Boolean.FALSE); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isFalse(); assertThat(res.getDependencies()).isEmpty(); }
@Test public void buildExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.build(Paths.get(tmpRoot.toAbsolutePath()+"/dummy").toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile()); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isTrue(); }
|
DefaultRemoteExecutor implements RemoteExecutor { @Override public CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath) { return internalBuild(projectPath, mavenRepoPath, settingsXmlPath, Boolean.FALSE, MavenCLIArgs.INSTALL); } DefaultRemoteExecutor(ExecutorService executorService); @Override CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath); @Override CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath, Boolean skipPrjDependenciesCreationList); @Override CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath); @Override CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath,
Boolean skipPrjDependenciesCreationList); @Override CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args); @Override CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args,
Boolean skipPrjDependenciesCreationList); }
|
@Test public void buildAndInstallNonExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildAndInstall(tmpRoot.toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile()); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isFalse(); }
@Test public void buildAndInstallSkipDepsNonExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildAndInstall(tmpRoot.toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile(), Boolean.FALSE); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isFalse(); assertThat(res.getDependencies()).isEmpty(); }
@Test public void buildAndInstallExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildAndInstall(Paths.get(tmpRoot.toAbsolutePath()+"/dummy").toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile()); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isTrue(); assertThat(res.getDependencies()).isNotEmpty(); assertThat(res.getDependencies().size()).isGreaterThan(0); }
@Test public void buildAndInstallSkipDepsExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildAndInstall(Paths.get(tmpRoot.toAbsolutePath()+"/dummy").toAbsolutePath().toString(), mavenRepoPath, TestUtilMaven.getSettingsFile(), Boolean.TRUE); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isTrue(); assertThat(res.getDependencies()).isEmpty(); }
|
DMNShapeFactory implements ShapeFactory<DMNDefinition, Shape> { @Override public Shape newShape(final DMNDefinition definition) { return delegateShapeFactory.newShape(definition); } @Inject DMNShapeFactory(final SVGShapeFactory svgShapeFactory,
final DMNConnectorShapeFactory dmnConnectorShapeFactory,
final DMNDecisionServiceShapeFactory dmnDecisionServiceShapeFactory,
final DelegateShapeFactory<DMNDefinition, Shape> delegateShapeFactory); @PostConstruct void init(); @Override Shape newShape(final DMNDefinition definition); @Override Glyph getGlyph(final String definitionId); @Override Glyph getGlyph(final String definitionId,
final Class<? extends GlyphConsumer> consumer); }
|
@Test public void testNewShape() { factory.newShape(definition); verify(delegateShapeFactory).newShape(definition); }
|
DefaultRemoteExecutor implements RemoteExecutor { @Override public CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args) { return internalBuild(projectPath, mavenRepoPath, Boolean.FALSE, args); } DefaultRemoteExecutor(ExecutorService executorService); @Override CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath); @Override CompletableFuture<KieCompilationResponse> build(String projectPath, String mavenRepoPath, String settingsXmlPath, Boolean skipPrjDependenciesCreationList); @Override CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath); @Override CompletableFuture<KieCompilationResponse> buildAndInstall(String projectPath, String mavenRepoPath, String settingsXmlPath,
Boolean skipPrjDependenciesCreationList); @Override CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args); @Override CompletableFuture<KieCompilationResponse> buildSpecialized(String projectPath, String mavenRepoPath, String[] args,
Boolean skipPrjDependenciesCreationList); }
|
@Test public void buildSpecializedNonExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildSpecialized(tmpRoot.toAbsolutePath().toString(), mavenRepoPath, new String[]{MavenCLIArgs.ALTERNATE_USER_SETTINGS + TestUtilMaven.getSettingsFile(), MavenCLIArgs.COMPILE}); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isFalse(); }
@Test public void buildSpecializedSkipDepsExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildSpecialized(Paths.get(tmpRoot.toAbsolutePath()+"/dummy").toAbsolutePath().toString(), mavenRepoPath, new String[]{MavenCLIArgs.ALTERNATE_USER_SETTINGS + TestUtilMaven.getSettingsFile(), MavenCLIArgs.COMPILE}, Boolean.TRUE); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isTrue(); }
@Test public void buildSpecializedSkipDepsNonExistentProject() throws Exception{ DefaultRemoteExecutor executor = new DefaultRemoteExecutor(executorService); CompletableFuture<KieCompilationResponse> futureRes = executor.buildSpecialized(tmpRoot.toAbsolutePath().toString(), mavenRepoPath, new String[]{MavenCLIArgs.ALTERNATE_USER_SETTINGS + TestUtilMaven.getSettingsFile(), MavenCLIArgs.COMPILE}, Boolean.TRUE); KieCompilationResponse res = futureRes.get(); assertThat(res.isSuccessful()).isFalse(); }
|
VerifierWebWorkerRegistry { public Optional<VerifierWebWorkerProvider> get(final String id) { if (map.containsKey(id)) { return Optional.of(map.get(id)); } else { return Optional.empty(); } } VerifierWebWorkerRegistry(); @Inject VerifierWebWorkerRegistry(@Any final Instance<VerifierWebWorkerProvider> verifierWebWorkerProviders); Optional<VerifierWebWorkerProvider> get(final String id); }
|
@Test public void noWebWorkerProviders() throws Exception { final Instance verifierWebWorkerProviders = mock(Instance.class); doReturn(new ArrayList<>().iterator()).when(verifierWebWorkerProviders).iterator(); assertFalse(new VerifierWebWorkerRegistry(verifierWebWorkerProviders).get("something").isPresent()); }
@Test public void wrongId() throws Exception { final Instance verifierWebWorkerProviders = mock(Instance.class); final ArrayList<Object> webWorkerProviders = new ArrayList<>(); webWorkerProviders.add(getWebWorkerProvider("somethingElse")); doReturn(webWorkerProviders.iterator()).when(verifierWebWorkerProviders).iterator(); assertFalse(new VerifierWebWorkerRegistry(verifierWebWorkerProviders).get("something").isPresent()); }
@Test public void correctId() throws Exception { final Instance verifierWebWorkerProviders = mock(Instance.class); final ArrayList<Object> webWorkerProviders = new ArrayList<>(); webWorkerProviders.add(getWebWorkerProvider("something")); doReturn(webWorkerProviders.iterator()).when(verifierWebWorkerProviders).iterator(); assertTrue(new VerifierWebWorkerRegistry(verifierWebWorkerProviders).get("something").isPresent()); }
|
IssuePresenter implements IsWidget { public void show(final Issue issue) { final String title = ExplanationProvider.toTitle(issue); view.setIssueTitle(title); view.setExplanation(ExplanationProvider.toHTML(issue)); view.setLines(makeRowNumbers(issue)); } @Inject IssuePresenter(final IssuePresenterView view); @Override Widget asWidget(); void show(final Issue issue); void clear(); }
|
@Test public void testShow() throws Exception { Issue issue = new Issue(Severity.WARNING, CheckType.REDUNDANT_ROWS, new HashSet<>(Arrays.asList(1, 2, 3)) ); screen.show(issue); verify(view).setIssueTitle("RedundantRows"); ArgumentCaptor<SafeHtml> safeHtmlArgumentCaptor = ArgumentCaptor.forClass(SafeHtml.class); verify(view).setExplanation(safeHtmlArgumentCaptor.capture()); assertEquals("<p>MissingRangeP1(1)</p>", safeHtmlArgumentCaptor.getValue() .asString()); verify(view).setLines("1, 2, 3"); }
@Test public void testIllegalVerifierState() { final Issue issue = new IllegalVerifierStateIssue(); screen.show(issue); verify(view).setIssueTitle("VerifierFailedTitle"); ArgumentCaptor<SafeHtml> safeHtmlArgumentCaptor = ArgumentCaptor.forClass(SafeHtml.class); verify(view).setExplanation(safeHtmlArgumentCaptor.capture()); assertEquals("<p>VerifierFailed</p>", safeHtmlArgumentCaptor.getValue().asString()); verify(view).setLines(""); }
@Test public void testShowEmptyIssue() throws Exception { screen.show(Issue.EMPTY); verify(view).setIssueTitle("---"); ArgumentCaptor<SafeHtml> safeHtmlArgumentCaptor = ArgumentCaptor.forClass(SafeHtml.class); verify(view).setExplanation(safeHtmlArgumentCaptor.capture()); assertEquals("---", safeHtmlArgumentCaptor.getValue() .asString()); verify(view).setLines(""); }
|
IssuePresenter implements IsWidget { public void clear() { view.setIssueTitle(""); view.setExplanation(new SafeHtml() { @Override public String asString() { return ""; } }); view.setLines(""); view.hideLines(); } @Inject IssuePresenter(final IssuePresenterView view); @Override Widget asWidget(); void show(final Issue issue); void clear(); }
|
@Test public void testClear() throws Exception { screen.clear(); verify(view).setIssueTitle(""); ArgumentCaptor<SafeHtml> safeHtmlArgumentCaptor = ArgumentCaptor.forClass(SafeHtml.class); verify(view).setExplanation(safeHtmlArgumentCaptor.capture()); assertEquals("", safeHtmlArgumentCaptor.getValue() .asString()); verify(view).hideLines(); verify(view).setLines(""); }
|
DMNShapeFactory implements ShapeFactory<DMNDefinition, Shape> { @Override public Glyph getGlyph(final String definitionId) { return delegateShapeFactory.getGlyph(definitionId); } @Inject DMNShapeFactory(final SVGShapeFactory svgShapeFactory,
final DMNConnectorShapeFactory dmnConnectorShapeFactory,
final DMNDecisionServiceShapeFactory dmnDecisionServiceShapeFactory,
final DelegateShapeFactory<DMNDefinition, Shape> delegateShapeFactory); @PostConstruct void init(); @Override Shape newShape(final DMNDefinition definition); @Override Glyph getGlyph(final String definitionId); @Override Glyph getGlyph(final String definitionId,
final Class<? extends GlyphConsumer> consumer); }
|
@Test public void testGetGlyph() { factory.getGlyph(DEFINITION_ID); verify(delegateShapeFactory).getGlyph(DEFINITION_ID); }
@Test public void testGetGlyphWithConsumer() { factory.getGlyph(DEFINITION_ID, ShapeFactory.GlyphConsumer.class); verify(delegateShapeFactory).getGlyph(DEFINITION_ID, ShapeFactory.GlyphConsumer.class); }
|
AnalysisReportScreen implements IsWidget { public void showReport(final AnalysisReport report) { LOGGER.finest("Received report for: " + report.getPlace().getPath()); if (!report.getPlace().equals(currentPlace)) { return; } view.showStatusComplete(); final List<Issue> issues = getIssues(report); final boolean isIllegalState = issues.stream() .filter(issue -> Objects.equals(issue.getCheckType(), CheckType.ILLEGAL_VERIFIER_STATE)) .count() > 0; if (isIllegalState) { view.hideProgressStatus(); } dataProvider.setList(issues); if (dataProvider.getList().isEmpty()) { fireIssueSelectedEvent(Issue.EMPTY); view.clearIssue(); } else { final Issue issue = dataProvider.getList().get(0); onSelect(issue); } } AnalysisReportScreen(); @Inject AnalysisReportScreen(final AnalysisReportScreenView view,
final Event<IssueSelectedEvent> issueSelectedEvent); void showReport(final AnalysisReport report); void setCurrentPlace(final PlaceRequest place); @Override Widget asWidget(); void onSelect(final Issue issue); void showStatus(final Status status); }
|
@Test public void testShowReport() throws Exception { Issue issue1 = new Issue(Severity.WARNING, CheckType.DEFICIENT_ROW, Collections.emptySet()); screen.showReport(getAnalysis(issue1)); assertEquals(1, dataProvider.getList() .size()); assertTrue(dataProvider.getList() .contains(issue1)); Issue issue2 = new Issue(Severity.ERROR, CheckType.CONFLICTING_ROWS, Collections.emptySet()); Issue issue3 = new Issue(Severity.WARNING, CheckType.SINGLE_HIT_LOST, Collections.emptySet()); screen.showReport(getAnalysis(issue2, issue3)); verify(view).showIssue(issue1); assertEquals(2, dataProvider.getList() .size()); assertFalse(dataProvider.getList() .contains(issue1)); assertTrue(dataProvider.getList() .contains(issue2)); assertTrue(dataProvider.getList() .contains(issue3)); }
@Test public void testShowReportIllegalState() { final Issue illegalStateIssue = new Issue(Severity.ERROR, CheckType.ILLEGAL_VERIFIER_STATE, Collections.emptySet()); screen.showReport(getAnalysis(illegalStateIssue)); assertEquals(1, dataProvider.getList().size()); assertTrue(dataProvider.getList().contains(illegalStateIssue)); verify(view).hideProgressStatus(); }
@Test public void testDoNotShowIfThereAreNoIssues() throws Exception { screen.showReport(getAnalysis()); assertEquals(0, dataProvider.getList() .size()); verify(view, never()).showIssue(any(Issue.class)); }
@Test public void testShowEverythingOnce() throws Exception { Issue issue2 = new Issue(Severity.WARNING, CheckType.REDUNDANT_ROWS, Collections.emptySet()); Issue issue3 = new Issue(Severity.WARNING, CheckType.REDUNDANT_ROWS, Collections.emptySet()); Issue issue4 = new Issue(Severity.WARNING, CheckType.REDUNDANT_ROWS, new HashSet<>(Arrays.asList(1, 2, 3))); Issue issue5 = new Issue(Severity.WARNING, CheckType.REDUNDANT_ROWS, new HashSet<>(Arrays.asList(1, 2, 3))); screen.showReport(getAnalysis(issue2, issue3, issue4, issue5)); assertEquals(2, dataProvider.getList() .size()); }
@Test public void testThePlaceInReportIsNotActive() throws Exception { screen.showReport(getAnalysis(PlaceRequest.NOWHERE)); verify(view, never()).showStatusComplete(); }
@Test public void testNoIssuesShowNothing() throws Exception { screen.showReport(getAnalysis()); verify(view, never()).showIssue(any(Issue.class)); verify(view).clearIssue(); verify(issueSelectedEvent, times(1)).fire(issueSelectedEventCaptor.capture()); assertEquals(Issue.EMPTY, issueSelectedEventCaptor.getValue().getIssue()); }
|
AnalysisReportScreen implements IsWidget { public void onSelect(final Issue issue) { view.showIssue(issue); fireIssueSelectedEvent(issue); } AnalysisReportScreen(); @Inject AnalysisReportScreen(final AnalysisReportScreenView view,
final Event<IssueSelectedEvent> issueSelectedEvent); void showReport(final AnalysisReport report); void setCurrentPlace(final PlaceRequest place); @Override Widget asWidget(); void onSelect(final Issue issue); void showStatus(final Status status); }
|
@Test public void testOnSelect() throws Exception { Issue issue1 = new Issue(Severity.WARNING, CheckType.REDUNDANT_ROWS, Collections.emptySet()); Issue issue2 = new Issue(Severity.WARNING, CheckType.SINGLE_HIT_LOST, Collections.emptySet()); screen.showReport(getAnalysis(issue1, issue2)); verify(issueSelectedEvent, times(1)).fire(issueSelectedEventCaptor.capture()); assertEquals(issue1, issueSelectedEventCaptor.getValue().getIssue()); screen.onSelect(issue2); verify(view).showIssue(issue2); verify(issueSelectedEvent, times(2)).fire(issueSelectedEventCaptor.capture()); assertEquals(issue2, issueSelectedEventCaptor.getValue().getIssue()); }
|
AnalysisReportScreen implements IsWidget { public void showStatus(final Status status) { view.showStatusTitle(status.getStart(), status.getEnd(), status.getTotalCheckCount()); } AnalysisReportScreen(); @Inject AnalysisReportScreen(final AnalysisReportScreenView view,
final Event<IssueSelectedEvent> issueSelectedEvent); void showReport(final AnalysisReport report); void setCurrentPlace(final PlaceRequest place); @Override Widget asWidget(); void onSelect(final Issue issue); void showStatus(final Status status); }
|
@Test public void testShowStatus() throws Exception { screen.showStatus(new Status("UUID", 1, 2, 3)); verify(view).showStatusTitle(1, 2, 3); }
|
AnalysisReportScreenViewImpl extends Composite implements AnalysisReportScreenView,
RequiresResize { @Override public void hideProgressStatus() { progressTooltip.getStyle().setVisibility(Style.Visibility.HIDDEN); } AnalysisReportScreenViewImpl(); @Inject AnalysisReportScreenViewImpl(final IssuePresenter issuePresenter); @Override void setUpDataProvider(ListDataProvider<Issue> dataProvider); @Override void setPresenter(final AnalysisReportScreen presenter); @Override void showIssue(Issue issue); @Override void clearIssue(); @Override void showStatusComplete(); @Override void showStatusTitle(final int start,
final int end,
final int totalCheckCount); @Override void hideProgressStatus(); @Override void onResize(); }
|
@Test public void testHideProgressStatus() { view.hideProgressStatus(); verify(style).setVisibility(Style.Visibility.HIDDEN); }
|
AnalysisReportScreenViewImpl extends Composite implements AnalysisReportScreenView,
RequiresResize { @Override public void showStatusComplete() { progressTooltip.getStyle().setVisibility(Style.Visibility.VISIBLE); progressPanel.getStyle().setColor("WHITE"); progressPanel.getStyle().setBackgroundColor("GREEN"); progressPanel.setInnerHTML(AnalysisConstants.INSTANCE.AnalysisComplete()); } AnalysisReportScreenViewImpl(); @Inject AnalysisReportScreenViewImpl(final IssuePresenter issuePresenter); @Override void setUpDataProvider(ListDataProvider<Issue> dataProvider); @Override void setPresenter(final AnalysisReportScreen presenter); @Override void showIssue(Issue issue); @Override void clearIssue(); @Override void showStatusComplete(); @Override void showStatusTitle(final int start,
final int end,
final int totalCheckCount); @Override void hideProgressStatus(); @Override void onResize(); }
|
@Test public void testStatusComplete() { view.showStatusComplete(); verify(style).setVisibility(Style.Visibility.VISIBLE); }
|
AnalysisReportScreenViewImpl extends Composite implements AnalysisReportScreenView,
RequiresResize { @Override public void showStatusTitle(final int start, final int end, final int totalCheckCount) { progressTooltip.getStyle().setVisibility(Style.Visibility.VISIBLE); progressPanel.getStyle().setColor("BLACK"); progressPanel.getStyle().setBackgroundColor("#ffc"); progressPanel.setInnerHTML(AnalysisConstants.INSTANCE.AnalysingChecks0To1Of2(start, end, totalCheckCount)); } AnalysisReportScreenViewImpl(); @Inject AnalysisReportScreenViewImpl(final IssuePresenter issuePresenter); @Override void setUpDataProvider(ListDataProvider<Issue> dataProvider); @Override void setPresenter(final AnalysisReportScreen presenter); @Override void showIssue(Issue issue); @Override void clearIssue(); @Override void showStatusComplete(); @Override void showStatusTitle(final int start,
final int end,
final int totalCheckCount); @Override void hideProgressStatus(); @Override void onResize(); }
|
@Test public void testStatusTitle() { view.showStatusTitle(0, 1, 1); verify(style).setVisibility(Style.Visibility.VISIBLE); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void initialiseAnalysis() { LOGGER.info("Initializing analysis."); events.setup(); decisionTableAnalyzer.activate(); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void areHandlersAreSetUpOnInit() throws Exception { controller.initialiseAnalysis(); verify(eventBus).addHandler(ValidateEvent.TYPE, controller); verify(eventBus).addHandler(DeleteRowEvent.TYPE, controller); verify(eventBus).addHandler(AfterColumnDeleted.TYPE, controller); verify(eventBus).addHandler(UpdateColumnDataEvent.TYPE, controller); verify(eventBus).addHandler(AppendRowEvent.TYPE, controller); verify(eventBus).addHandler(InsertRowEvent.TYPE, controller); verify(eventBus).addHandler(AfterColumnInserted.TYPE, controller); }
@Test public void start() throws Exception { controller.initialiseAnalysis(); verify(analyzer).activate(); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void terminateAnalysis() { LOGGER.info("Terminating analysis."); events.teardown(); decisionTableAnalyzer.terminate(); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void terminate() throws Exception { controller.terminateAnalysis(); verify(analyzer).terminate(); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void onValidate(final ValidateEvent event) { decisionTableAnalyzer.analyze(event.getUpdates()); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void analyze() throws Exception { final ArrayList<Coordinate> updates = new ArrayList<>(); controller.onValidate(new ValidateEvent(updates)); verify(analyzer).analyze(updates); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void onAfterDeletedColumn(final AfterColumnDeleted event) { decisionTableAnalyzer.deleteColumns(event.getFirstColumnIndex(), event.getNumberOfColumns()); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void deleteColumns() throws Exception { controller.onAfterDeletedColumn(new AfterColumnDeleted(1, 2)); verify(analyzer).deleteColumns(1, 2); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void onAppendRow(final AppendRowEvent event) { decisionTableAnalyzer.appendRow(); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void appendRow() throws Exception { controller.onAppendRow(new AppendRowEvent()); verify(analyzer).appendRow(); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void onDeleteRow(final DeleteRowEvent event) { decisionTableAnalyzer.deleteRow(event.getIndex()); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void deleteRow() throws Exception { controller.onDeleteRow(new DeleteRowEvent(10)); verify(analyzer).deleteRow(10); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void onInsertRow(final InsertRowEvent event) { decisionTableAnalyzer.insertRow(event.getIndex()); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void insertRow() throws Exception { controller.onInsertRow(new InsertRowEvent(10)); verify(analyzer).insertRow(10); }
|
AnalyzerControllerImpl implements AnalyzerController,
ValidateEvent.Handler,
DeleteRowEvent.Handler,
AfterColumnDeleted.Handler,
UpdateColumnDataEvent.Handler,
AppendRowEvent.Handler,
InsertRowEvent.Handler,
AfterColumnInserted.Handler { @Override public void onUpdateColumnData(final UpdateColumnDataEvent event) { decisionTableAnalyzer.updateColumns(event.getColumnData().size()); } AnalyzerControllerImpl(final DecisionTableAnalyzer decisionTableAnalyzer,
final EventBus eventBus); @Override void initialiseAnalysis(); @Override void terminateAnalysis(); @Override void onValidate(final ValidateEvent event); @Override void onAfterDeletedColumn(final AfterColumnDeleted event); @Override void onAfterColumnInserted(final AfterColumnInserted event); @Override void onAppendRow(final AppendRowEvent event); @Override void onDeleteRow(final DeleteRowEvent event); @Override void onInsertRow(final InsertRowEvent event); @Override void onUpdateColumnData(final UpdateColumnDataEvent event); }
|
@Test public void updateColumns() throws Exception { final ArrayList<CellValue<? extends Comparable<?>>> columnData = new ArrayList<>(); columnData.add(mock(CellValue.class)); controller.onUpdateColumnData(new UpdateColumnDataEvent(10, columnData)); verify(analyzer).updateColumns(1); }
|
DMNDecisionServiceSVGMutableShapeImpl extends SVGMutableShapeImpl<DecisionService, DMNDecisionServiceSVGShapeDef> { @Override protected void applyCustomProperties(final Node<View<DecisionService>, Edge> element, final MutationContext mutationContext) { final DecisionService instance = getDefinition(element); final DecisionServiceSVGShapeView decisionServiceSVGShapeView = (DecisionServiceSVGShapeView) getShapeView(); decisionServiceSVGShapeView.setDividerLineY(instance.getDividerLineY().getValue()); } DMNDecisionServiceSVGMutableShapeImpl(final DMNDecisionServiceSVGShapeDef shapeDef,
final SVGShapeViewImpl view); }
|
@Test public void testApplyCustomProperties() { final DecisionServiceDividerLineY divider = new DecisionServiceDividerLineY(25.0); when(decisionServiceDefinition.getDividerLineY()).thenReturn(divider); svgMutableShape.applyCustomProperties(decisionServiceNode, mutationContext); verify(view).setDividerLineY(eq(25.0)); }
|
Events { public void setup() { if (eventBusHandlerRegistrations.isEmpty()) { eventBusHandlerRegistrations.add(eventBus.addHandler(ValidateEvent.TYPE, analyzerController)); eventBusHandlerRegistrations.add(eventBus.addHandler(DeleteRowEvent.TYPE, analyzerController)); eventBusHandlerRegistrations.add(eventBus.addHandler(AfterColumnDeleted.TYPE, analyzerController)); eventBusHandlerRegistrations.add(eventBus.addHandler(UpdateColumnDataEvent.TYPE, analyzerController)); eventBusHandlerRegistrations.add(eventBus.addHandler(AppendRowEvent.TYPE, analyzerController)); eventBusHandlerRegistrations.add(eventBus.addHandler(InsertRowEvent.TYPE, analyzerController)); eventBusHandlerRegistrations.add(eventBus.addHandler(AfterColumnInserted.TYPE, analyzerController)); } } Events(final EventBus eventBus,
final AnalyzerControllerImpl analyzerController); void setup(); void teardown(); }
|
@Test public void setUpWorksOnlyOnce() throws Exception { events.setup(); verify( eventBus ).addHandler( ValidateEvent.TYPE, analyzerController ); reset( eventBus ); events.setup(); verify( eventBus, never() ).addHandler( ValidateEvent.TYPE, analyzerController ); }
|
VerifierWebWorkerConnectionImpl implements VerifierWebWorkerConnection { @Override public void activate() { receiver.activate(); if (worker == null) { startWorker(); poster.post(initialize); } else { poster.post(new RequestStatus()); } } VerifierWebWorkerConnectionImpl(final Initialize initialize,
final String pathToVerifier,
final Poster poster,
final Receiver receiver); @Override void activate(); @Override void terminate(); }
|
@Test public void firstActivationStartWebWorker() throws Exception { verifierWebWorkerConnection.activate(); verify(receiver).activate(); verify(receiver).setUp(any()); verify(poster).setUp(any()); verify(poster).post(any(Initialize.class)); }
@Test public void secondActivationDoesNotStartWebWorker() throws Exception { verifierWebWorkerConnection.activate(); reset(receiver, poster); verifierWebWorkerConnection.activate(); verify(receiver).activate(); verify(receiver, never()).setUp(any()); verify(poster, never()).setUp(any()); verify(poster).post(any(RequestStatus.class)); }
|
AnalysisReporter implements Reporter { public void sendReport(final AnalysisReport report) { reportScreen.showReport(report); } AnalysisReporter(final PlaceRequest place,
final AnalysisReportScreen reportScreen); void sendReport(final AnalysisReport report); @Override void sendReport(final Set<Issue> issues); @Override void sendStatus(final Status status); @Override void activate(); }
|
@Test public void sendReport() { new AnalysisReporter(place, reportScreen).sendReport(new HashSet<>()); verify(reportScreen).showReport(analysisReportArgumentCaptor.capture()); final AnalysisReport report = analysisReportArgumentCaptor.getValue(); assertTrue(report.getAnalysisData().isEmpty()); assertEquals(place, report.getPlace()); }
|
MigrationConfigurationFactoryImpl extends ConfigurationFactoryImpl implements ConfigurationFactory { @Override public ConfigGroup newConfigGroup(ConfigType type, final String name, final String description) { if (ConfigType.SPACE.equals(type)) { type = ConfigType.ORGANIZATIONAL_UNIT; } final ConfigGroup configGroup = new ConfigGroup(); configGroup.setDescription(description); configGroup.setName(name); configGroup.setType(type); configGroup.setEnabled(true); return configGroup; } MigrationConfigurationFactoryImpl(); @Inject MigrationConfigurationFactoryImpl(final PasswordService secureService); @Override ConfigGroup newConfigGroup(ConfigType type,
final String name,
final String description); @Override ConfigGroup newConfigGroup(final ConfigType type,
final String namespace,
final String name,
final String description); }
|
@Test public void newConfigGroupWithoutNamespaceTest() { final ConfigGroup configGroup = configurationFactory.newConfigGroup(ConfigType.GLOBAL, "my-config", "my-description"); assertEquals(ConfigType.GLOBAL, configGroup.getType()); assertEquals("my-config", configGroup.getName()); assertEquals("my-description", configGroup.getDescription()); assertTrue(configGroup.isEnabled()); }
@Test public void newConfigGroupWithNamespaceTest() { final ConfigGroup configGroup = configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "my-namespace", "my-config", "my-description"); assertEquals(ConfigType.REPOSITORY, configGroup.getType()); assertEquals("my-config", configGroup.getName()); assertEquals("my-description", configGroup.getDescription()); assertTrue(configGroup.isEnabled()); }
|
BPMNFormAdapter extends AbstractFormAdapter { static boolean isBPMNFile(final String fileName) { return ResourceType.getResourceType("BPMN2").matchesExtension(fileName); } BPMNFormAdapter(MigrationContext migrationContext); }
|
@Test public void testIsBPMNFile() throws Exception { assertTrue(BPMNFormAdapter.isBPMNFile("abc.bpmn")); assertTrue(BPMNFormAdapter.isBPMNFile("abc.bpmn2")); assertTrue(BPMNFormAdapter.isBPMNFile("abc.bpmn-cm")); assertFalse(BPMNFormAdapter.isBPMNFile("abc.bpmn2-cm")); }
|
ToolConfig { public static ToolConfig parse(String[] args) throws ParseException { Options opts = OPTIONS; return new ToolConfig(new DefaultParser().parse(opts, args)); } ToolConfig(CommandLine cli); ToolConfig(Path target, boolean batch); Path getTarget(); boolean isBatch(); static ToolConfig parse(String[] args); static void printHelp(PrintStream stream, String app); }
|
@Test(expected = ParseException.class) public void testNoTargetParameter() throws ParseException { final String[] args = {}; defaultFactory.parse(args); }
@Test(expected = MissingArgumentException.class) public void testNoTargetArgument() throws ParseException { final String[] args = {"-t"}; defaultFactory.parse(args); }
|
ToolConfig { public static void printHelp(PrintStream stream, String app) { HelpFormatter formatter = new HelpFormatter(); formatter.printHelp(new PrintWriter(stream, true), formatter.getWidth(), app, HELP_HEADER, OPTIONS, formatter.getLeftPadding(), formatter.getDescPadding(), HELP_FOOTER, true); } ToolConfig(CommandLine cli); ToolConfig(Path target, boolean batch); Path getTarget(); boolean isBatch(); static ToolConfig parse(String[] args); static void printHelp(PrintStream stream, String app); }
|
@Test public void testPrintHelp() throws IOException { final String APP_NAME = "myAppName"; File tf = File.createTempFile("printTestFile", ".txt"); try (PrintStream ps = new PrintStream(tf); BufferedReader br = new BufferedReader(new FileReader(tf))) { defaultFactory.printHelp(ps, APP_NAME); assertTrue(br.readLine().contains(APP_NAME)); } }
|
DecisionServiceDividerLine extends Line { SVGPrimitiveShape asSVGPrimitiveShape() { final SVGPrimitiveShape divider = SVGPrimitiveFactory.newSVGPrimitiveShape(this, false, null); divider.setDragEnabled(true); return divider; } DecisionServiceDividerLine(final Supplier<Double> dynamicWidthSupplier); }
|
@Test public void testAsSVGPrimitiveShape() { final SVGPrimitiveShape primitiveShape = line.asSVGPrimitiveShape(); assertThat(primitiveShape.get().isDraggable()).isTrue(); }
|
ToolConfig { public Path getTarget() { return target; } ToolConfig(CommandLine cli); ToolConfig(Path target, boolean batch); Path getTarget(); boolean isBatch(); static ToolConfig parse(String[] args); static void printHelp(PrintStream stream, String app); }
|
@Test public void testGetTarget() throws ParseException { final String[] args = {"-t", "/fake/dir"}; CommandLine cl = new CLIManager().parse(args); Path path = new ToolConfig(cl).getTarget(); assertEquals(2, path.getNameCount()); assertEquals("fake", path.getName(0).toString()); }
|
TemporaryNiogitService { public void importProjects(Path actualTarget) { OrganizationalUnit ou = ouService.createOrganizationalUnit(OU_NAME, "org.migration", Collections.emptyList(), Collections.singletonList(new Contributor(OU_OWNER, ContributorType.OWNER))); String repositoryURL = actualTarget.toUri().toString(); RepositoryEnvironmentConfigurations configurations = new RepositoryEnvironmentConfigurations(); Map<String, Object> configMap = configurations.getConfigurationMap(); configMap.put(EnvironmentParameters.AVOID_INDEX, "true"); configMap.put("origin", repositoryURL); Repository repo = repoService.createRepository(ou, GitRepository.SCHEME.toString(), TMP_REPO_ALIAS, configurations); WorkspaceProject project = projectService.resolveProject(repo); migrationService.migrate(project); repoService.removeRepository(ou.getSpace(), TMP_REPO_ALIAS); } @Inject TemporaryNiogitService(OrganizationalUnitService ouService,
RepositoryService repoService,
WorkspaceProjectService projectService,
WorkspaceProjectMigrationService migrationService); void importProjects(Path actualTarget); }
|
@Test public void removeMigrationRepoAfterMigration() throws Exception { service.importProjects(target); verify(repoService).removeRepository(eq(new Space(OU_NAME)), eq(TMP_REPO_ALIAS)); }
@Test public void migrateCalledOnLegacyProject() throws Exception { service.importProjects(target); verify(migrationService).migrate(projectCaptor.capture()); WorkspaceProject migrated = projectCaptor.getValue(); assertEquals(TMP_REPO_ALIAS, migrated.getRepository().getAlias()); }
@Test public void repoConfigurationHasOriginAndAvoidIndex() throws Exception { service.importProjects(target); verify(repoService).createRepository(any(), any(), any(), configsCaptor.capture()); RepositoryEnvironmentConfigurations configs = configsCaptor.getValue(); assertEquals(target.toUri().toString(), assertValue(configs.getOrigin(), String.class)); assertEquals("true", configs.getConfigurationMap().get(AVOID_INDEX)); }
|
ConfigGroupsMigrationService { public void groupSystemConfigGroups() { try { startBatch(); system.out().println("Moving existing configurations to their type directories..."); groupConfigGroupsByType(); system.out().println("Moving existing repositories configurations to their space directories..."); groupRepositoryConfigGroupsBySpace(); } finally { endBatch(); } } ConfigGroupsMigrationService(); @Inject ConfigGroupsMigrationService(final @Named("system") Repository systemRepository,
final ConfigGroupMarshaller marshaller,
final @Named("configIO") IOService ioService,
final @Named("systemFS") FileSystem fs,
final SystemAccess system,
final User identity); void groupSystemConfigGroups(); }
|
@Test public void groupSystemConfigGroupsTest() { createConfigGroupsWithOldConfigurationService(); migrateConfigGroups(); checkConfigGroupsWithNewConfigurationService(); }
|
FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; }
|
@Test public void testCreateForm() { when(formDefinitionSerializer.serialize(any())).thenAnswer(this::verifyNewForm); FormModel formModel = mock(FormModel.class); Path resultPath = formEditorService.createForm(path, FULL_FORM_NAME, formModel); assertNotNull(resultPath); }
@Test public void testCreateFormThatExistsOnVFS() { try { when(ioService.exists(any())).thenReturn(true); FormModel formModel = mock(FormModel.class); formEditorService.createForm(path, FULL_FORM_NAME, formModel); fail("If form exists we shouldn't be here"); } catch (FileAlreadyExistsException ex) { } }
|
FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; }
|
@Test public void testDeleteForm() { formEditorService.delete(path, COMMIT_MESSAGE); verify(moduleService).resolveModule(path); verify(deleteService).delete(path, COMMIT_MESSAGE); }
@Test public void testDeleteFormWrongProject() { when(moduleService.resolveModule(any())).thenReturn(null); formEditorService.delete(path, COMMIT_MESSAGE); verify(moduleService).resolveModule(path); verify(deleteService, never()).delete(path, COMMIT_MESSAGE); }
@Test public void testDeleteFormWithException() { when(moduleService.resolveModule(any())).thenThrow(new IllegalStateException("Testing exception handling")); formEditorService.delete(path, COMMIT_MESSAGE); verify(moduleService).resolveModule(path); verify(deleteService, never()).delete(path, COMMIT_MESSAGE); }
|
DecisionServiceDividerLine extends Line { @Override protected boolean prepare(final Context2D context, final Attributes attr, final double alpha) { context.beginPath(); context.moveTo(0.0, 0.0); context.lineTo(dynamicWidthSupplier.get(), 0.0); return true; } DecisionServiceDividerLine(final Supplier<Double> dynamicWidthSupplier); }
|
@Test public void testPrepare() { assertThat(line.prepare(context, attributes, 1.0)).isTrue(); verify(context).beginPath(); verify(context).moveTo(eq(0.0), eq(0.0)); verify(context).lineTo(eq(WIDTH), eq(0.0)); }
|
FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; }
|
@Test public void testConstructContent() throws IOException, SourceFormModelNotFoundException { String formContent = IOUtils.toString(new InputStreamReader(this.getClass().getResourceAsStream("test.frm"))); when(ioService.readAllString(any())).thenReturn(formContent); FormModelerContent content = formEditorService.constructContent(path, overview); verify(modelHandlerManager).getFormModelHandler(any()); verify(dataObjectFormModelHandler).init(any(), any()); verify(dataObjectFormModelHandler).checkSourceModel(); verify(dataObjectFormModelHandler).synchronizeFormModel(); verify(resourceOpenedEvent).fire(any()); assertNotNull(content); assertNull(content.getError()); assertEquals(RenderMode.READ_ONLY_MODE, content.getRenderingContext().getRenderMode()); }
@Test public void testConstructContentWithCheckModelFailure() throws IOException, SourceFormModelNotFoundException { SourceFormModelNotFoundException exception = new SourceFormModelNotFoundException("exception", null, "exception", null, "model", null); doThrow(exception) .when(dataObjectFormModelHandler).checkSourceModel(); String formContent = IOUtils.toString(new InputStreamReader(this.getClass().getResourceAsStream("test.frm"))); when(ioService.readAllString(any())).thenReturn(formContent); FormModelerContent content = formEditorService.constructContent(path, overview); verify(modelHandlerManager).getFormModelHandler(any()); verify(dataObjectFormModelHandler).init(any(), any()); verify(dataObjectFormModelHandler).checkSourceModel(); verify(dataObjectFormModelHandler, never()).synchronizeFormModel(); verify(resourceOpenedEvent).fire(any()); assertNotNull(content); assertNotNull(content.getError()); assertEquals(exception.getShortKey(), content.getError().getShortKey()); assertArrayEquals(exception.getShortKeyParams(), content.getError().getShortKeyParams()); assertEquals(exception.getLongKey(), content.getError().getLongKey()); assertArrayEquals(exception.getLongKeyParams(), content.getError().getLongKeyParams()); }
@Test public void testConstructContentWithUnexpectedFailure() { FormModelerContent content = formEditorService.constructContent(path, overview); verify(modelHandlerManager, never()).getFormModelHandler(any()); verify(resourceOpenedEvent).fire(any()); assertNotNull(content); assertNotNull(content.getError()); }
|
AbstractFormDefinitionHelper { public boolean supports(Path path) { return path.getFileName().endsWith("." + FormResourceTypeDefinition.EXTENSION); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); boolean supports(Path path); void postProcess(Path source, Path destination); }
|
@Test public void testSupports() { Assertions.assertThat(helper.supports(originalPath)) .isNotNull() .isTrue(); Path wrongPath = mock(Path.class); when(wrongPath.getFileName()).thenReturn("wrongh.path"); Assertions.assertThat(helper.supports(wrongPath)) .isNotNull() .isFalse(); }
|
AbstractFormDefinitionHelper { public void postProcess(Path source, Path destination) { org.uberfire.java.nio.file.Path destinationNioPath = Paths.convert(destination); FormDefinition formDefinition = serializer.deserialize(ioService.readAllString(destinationNioPath)); processFormDefinition(formDefinition, destination); ioService.write(destinationNioPath, serializer.serialize(formDefinition), commentedOptionFactory.makeCommentedOption("Updating form [" + destination.toURI() + "].")); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); boolean supports(Path path); void postProcess(Path source, Path destination); }
|
@Test public void testPostProcess() { helper.postProcess(originalPath, destinationPath); verify(ioService).readAllString(any()); verify(serializer).deserialize(anyString()); verify(serializer).serialize(eq(formDefinition)); verifyForm(formDefinition); verify(commentedOptionFactory).makeCommentedOption(anyString()); ioService.write(any(), anyString(), any()); }
|
NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); }
|
@Test public void testAssetNameValidationWithFormModelPresenterFailure() { when(formModelsPresenter.isValid()).thenReturn(false); handler.validate(NEW_FORM_NAME, validatorCallback); verify(formModelsPresenter, times(1)).isValid(); verify(validatorCallback, times(1)).onFailure(); }
@Test public void testAssetNameValidationWithValidationServiceFailure() { when(formModelsPresenter.isValid()).thenReturn(true); when(validationService.isFileNameValid(anyString())).thenReturn(false); handler.validate(NEW_FORM_NAME, validatorCallback); verify(formModelsPresenter, times(1)).isValid(); verify(validatorCallback, times(1)).onFailure(anyString()); }
@Test public void testAssetNameValidationSuccessful() { when(formModelsPresenter.isValid()).thenReturn(true); when(validationService.isFileNameValid(anyString())).thenReturn(true); handler.validate(NEW_FORM_NAME, validatorCallback); verify(formModelsPresenter, times(1)).isValid(); verify(validatorCallback, times(1)).onSuccess(); }
|
NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); }
|
@Test public void testSuccessfulCreation() { handler.create(pkg, NEW_FORM_NAME, newResourcePresenter); verify(translationService).getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse); verify(busyIndicatorView).showBusyIndicator(anyString()); verify(busyIndicatorView).hideBusyIndicator(); verify(newResourcePresenter).complete(); verify(notificationEvent).fire(any()); verify(newResourceSuccessEvent).fire(any()); verify(placeManager).goTo(any(Path.class)); }
@Test public void testFailedCreation() { when(formEditorService.createForm(any(), anyString(), any())).thenThrow(new IllegalStateException("Something wrong happened")); handler.create(pkg, NEW_FORM_NAME, newResourcePresenter); verify(translationService).getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse); verify(busyIndicatorView).showBusyIndicator(anyString()); verify(errorCallback).error(any(), any()); }
|
MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override public Type<MoveDividerStartHandler> getAssociatedType() { return TYPE; } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStartHandler> getAssociatedType(); static final Type<MoveDividerStartHandler> TYPE; }
|
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerStartEvent.TYPE); }
|
EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; }
|
@Test public void testDroppingNewField() { editorFieldLayoutComponent.getShowWidget(ctx); verify(editorFieldLayoutComponent).init(context, fieldDefinition); verify(fieldRenderer).init(context, fieldDefinition); verify(fieldRenderer).renderWidget(); }
@Test public void testRenderingExistingField() { testDroppingNewField(); editorFieldLayoutComponent.getShowWidget(ctx); verify(editorFieldLayoutComponent, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(2)).renderWidget(); }
@Test public void testReceivingWrongContextResponses() { testDroppingNewField(); verify(editorFieldLayoutComponent, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(1)).init(context, fieldDefinition); verify(editorFieldLayoutComponent, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(1)).init(context, fieldDefinition); }
@Test public void testReceivingResponsesWhenDisabled() { verify(editorFieldLayoutComponent, never()).init(context, fieldDefinition); verify(fieldRenderer, never()).init(context, fieldDefinition); }
|
EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; }
|
@Test public void testOpenFieldProperties() { testDroppingNewField(); ModalConfigurationContext modalConfigurationContext = mock(ModalConfigurationContext.class); when(modalConfigurationContext.getComponentProperties()).thenReturn(layoutComponent.getProperties()); editorFieldLayoutComponent.getConfigurationModal(modalConfigurationContext); verify(propertiesRenderer).render(any()); verify(propertiesRenderer).getView(); verify(fieldPropertiesRendererView).getPropertiesModal(); }
@Test public void testHelperOnCloseWithContext() { ModalConfigurationContext ctx = mock(ModalConfigurationContext.class); when(ctx.getComponentProperties()).thenReturn(mock(Map.class)); testDroppingNewField(); editorFieldLayoutComponent.getConfigurationModal(ctx); propertiesRendererHelper.onClose(); assertFalse(editorFieldLayoutComponent.showProperties); verify(ctx).configurationCancelled(); }
|
EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void setSettingValue(String key, String value) { if (FORM_ID.equals(key)) { formId = Optional.of(value); } else if (FIELD_ID.equals(key)) { fieldId = Optional.of(value); } } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; }
|
@Test public void testHardCodedDragAndDropMethods() { editorFieldLayoutComponent.setSettingValue(EditorFieldLayoutComponent.FORM_ID, formDefinition.getId()); editorFieldLayoutComponent.setSettingValue(EditorFieldLayoutComponent.FIELD_ID, fieldDefinition.getId()); verifyDragAndDropMethods(); }
|
EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; }
|
@Test public void testOnPressOk() { testOnPressOk(false, false); }
@Test public void testHelperOnPressOk() { FieldDefinition fieldCopy = setupFormEditorHelper(); propertiesRendererHelper.onPressOk(fieldCopy); verify(editorFieldLayoutComponent).onPressOk(fieldCopy); }
|
EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override protected IsWidget generateContent(RenderingContext ctx) { LayoutComponent component = ctx.getComponent(); if (fieldRenderer == null) { initContent(component.getProperties()); } else { renderContent(); } return content; } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; }
|
@Test public void testFieldPartsAdded() { Set<String> parts = Stream.of("p1", "p2").collect(Collectors.toSet()); when(fieldRenderer.getFieldParts()).thenReturn(parts); editorFieldLayoutComponent.generateContent(ctx); editorFieldLayoutComponent.addComponentParts(ctx.getComponent()); Set<String> expectedParts = layoutComponent.getParts().stream().map(p -> p.getPartId()).collect(Collectors.toSet()); parts = Stream.of("p1", "p3").collect(Collectors.toSet()); when(fieldRenderer.getFieldParts()).thenReturn(parts); editorFieldLayoutComponent.generateContent(ctx); editorFieldLayoutComponent.addComponentParts(ctx.getComponent()); expectedParts = layoutComponent.getParts().stream().map(p -> p.getPartId()).collect(Collectors.toSet()); assertEquals(parts, expectedParts); }
|
MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override protected void dispatch(final MoveDividerStartHandler handler) { handler.onMoveDividerStart(this); } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStartHandler> getAssociatedType(); static final Type<MoveDividerStartHandler> TYPE; }
|
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerStart(eq(event)); }
|
DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } static T deepClone(T instance); }
|
@Test public void listWithBindableTypesTest() { PowerMockito.when(BindableProxyFactory.getBindableProxy(Obj.class)).thenReturn(new BindableProxyImpl()); Obj obj = new Obj("test"); List<Obj> asList = Arrays.asList(obj); DeepCloneHelper.doDeepCloneList(asList); verifyStatic(BindableProxyFactory.class, times(1)); BindableProxyFactory.getBindableProxy(Obj.class); verifyStatic(BindableProxyFactory.class, times(1)); BindableProxyFactory.getBindableProxy(obj); }
@Test public void listWithoutBindableTypesTest() { PowerMockito.when(BindableProxyFactory.getBindableProxy(any(String.class))).thenReturn(null); String test = "test"; List<String> asList = Arrays.asList(test); DeepCloneHelper.doDeepCloneList(asList); verifyStatic(BindableProxyFactory.class, times(1)); BindableProxyFactory.getBindableProxy(String.class); verifyStatic(BindableProxyFactory.class, times(0)); BindableProxyFactory.getBindableProxy(test); }
|
FieldPropertiesRenderer implements IsWidget { public void render(final FieldPropertiesRendererHelper helper) { this.helper = helper; this.originalField = helper.getCurrentField(); this.fieldCopy = doCopy(originalField); this.acceptChanges = false; render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); }
|
@Test public void testRender() { loadContent(); renderer.render(helper); assertSame(helper, renderer.helper); assertNotNull(renderer.fieldCopy); verify(renderer, times(1)).doCopy(any()); verify(fieldManager).getFieldFromProvider(any(), any()); }
|
FieldPropertiesRenderer implements IsWidget { public void onFieldTypeChange(final String typeCode) { fieldCopy = helper.onFieldTypeChange(unwrap(fieldCopy), typeCode); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); }
|
@Test public void testOnFieldTypeChange() { testRender(); when(helper.onFieldTypeChange(any(), anyString())).thenReturn(lastNameField); renderer.onFieldTypeChange(TYPE_CODE); verify(helper).onFieldTypeChange(renderer.fieldCopy, TYPE_CODE); verify(renderer, atLeastOnce()).render(); }
|
FieldPropertiesRenderer implements IsWidget { public void onFieldBindingChange(final String bindingExpression) { fieldCopy = helper.onFieldBindingChange(fieldCopy, bindingExpression); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); }
|
@Test public void testOnFieldBindingChange() { testRender(); when(helper.onFieldBindingChange(any(), anyString())).thenReturn(lastNameField); renderer.onFieldBindingChange(lastNameField.getId()); verify(helper).onFieldBindingChange(renderer.fieldCopy, lastNameField.getId()); verify(renderer, atLeastOnce()).render(); }
|
FieldPropertiesRenderer implements IsWidget { public FieldPropertiesRendererView getView() { return view; } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); }
|
@Test public void testGetView() { loadContent(); assertSame(view, renderer.getView()); }
|
FieldPropertiesRenderer implements IsWidget { @Override public Widget asWidget() { return view.asWidget(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); }
|
@Test public void testAsWidget() { loadContent(); renderer.asWidget(); verify(view).asWidget(); }
|
FormEditorHelper { public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGenerateUnboundFieldName() { String fieldName = formEditorHelper.generateUnboundFieldName(nameField); assertEquals(fieldName, FormEditorHelper.UNBOUND_FIELD_NAME_PREFFIX + nameField.getId()); }
|
FormEditorHelper { public FormModelerContent getContent() { return content; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetContent() { FormModelerContent resContent = formEditorHelper.getContent(); assertEquals(resContent, content); }
|
FormEditorHelper { public FormDefinition getFormDefinition() { return content.getDefinition(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetFormDefinition() { FormDefinition formDefinition = formEditorHelper.getFormDefinition(); assertEquals(formDefinition, content.getDefinition()); }
|
MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); static final Type<MoveDividerStepHandler> TYPE; }
|
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerStepEvent.TYPE); }
|
FormEditorHelper { public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetRenderingContext() { FormEditorRenderingContext renderingContext = formEditorHelper.getRenderingContext(); assertEquals(renderingContext, content.getRenderingContext()); }
|
FormEditorHelper { public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetAvailableFields() { Map<String, FieldDefinition> availableFields = formEditorHelper.getAvailableFields(); assertEquals("There should be no available field", employeeFields.size(), availableFields.size()); }
|
FormEditorHelper { public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetFormField() { when(formDefinition.getFieldById(anyString())).thenReturn(nameField); content.setDefinition(formDefinition); FieldDefinition formField = formEditorHelper.getFormField(nameField.getId()); assertEquals(formField, nameField); }
|
FormEditorHelper { public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetBaseFieldsDraggables() { Collection<EditorFieldLayoutComponent> draggables = formEditorHelper.getBaseFieldsDraggables(); assertNotNull(draggables); assertFalse(draggables.isEmpty()); }
|
FormEditorHelper { public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testAddAvailableField() { formEditorHelper.addAvailableField(employeeFields.get(0)); Map<String, FieldDefinition> availableFields = formEditorHelper.getAvailableFields(); assertEquals("The added field should be returned in available fields", employeeFields.size() + 1, availableFields.size()); }
|
FormEditorHelper { public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetCompatibleModelFields() { List<String> compatibleModelFields = formEditorHelper.getCompatibleModelFields(nameField); Assertions.assertThat(compatibleModelFields) .hasSize(2) .contains(lastNameField.getId(), nameField.getId()); compatibleModelFields = formEditorHelper.getCompatibleModelFields(ageField); Assertions.assertThat(compatibleModelFields).containsOnly(ageField.getId()); compatibleModelFields = formEditorHelper.getCompatibleModelFields(weightField); Assertions.assertThat(compatibleModelFields) .hasSize(1) .containsOnly(weightField.getId()); IntegerSliderDefinition slider = new IntegerSliderDefinition(); slider.setId("slider"); slider.setName("slider"); slider.setLabel("slider"); slider.setBinding("slider"); compatibleModelFields = formEditorHelper.getCompatibleModelFields(slider); Assertions.assertThat(compatibleModelFields) .hasSize(1) .containsOnly(ageField.getId()); }
|
FormEditorHelper { public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testGetCompatibleFieldTypes() { Collection<String> fieldCodes = formEditorHelper.getCompatibleFieldTypes(nameField); assertFalse(fieldCodes.isEmpty()); }
|
FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testSwitchToNullBinding() { FieldDefinition result = formEditorHelper.switchToField(nameField, null); Assertions.assertThat(result.getId()).isNotEqualTo(nameField.getId()); Assertions.assertThat(result.getName()).isNotEqualTo(nameField.getName()); Assertions.assertThat(result.getBinding()).isNullOrEmpty(); Assertions.assertThat(result.getBinding()).isNotEqualTo(nameField.getBinding()); Assertions.assertThat(result.getStandaloneClassName()).isEqualTo(nameField.getStandaloneClassName()); }
@Test public void testSwitchToDynamicBinding() { FieldDefinition result = formEditorHelper.switchToField(nameField, DYNAMIC_BINDING); Assertions.assertThat(result.getId()).isNotEqualTo(nameField.getId()); Assertions.assertThat(result.getName()).isEqualTo(DYNAMIC_BINDING); Assertions.assertThat(result.getBinding()).isEqualTo(DYNAMIC_BINDING); Assertions.assertThat(result.getStandaloneClassName()).isEqualTo(nameField.getStandaloneClassName()); }
|
FormEditorHelper { public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testSwitchToFieldType() { content.getDefinition().getFields().addAll(employeeFields); formEditorHelper.getAvailableFields().clear(); FieldDefinition fieldDefinition = formEditorHelper.switchToFieldType(nameField, TextAreaFieldDefinition.FIELD_TYPE.getTypeName()); assertEquals(TextAreaFieldDefinition.class, fieldDefinition.getClass()); }
|
MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); static final Type<MoveDividerStepHandler> TYPE; }
|
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerStep(eq(event)); }
|
FormEditorHelper { public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testRemoveAvailableField() { formEditorHelper.addAvailableField(nameField); assertTrue(formEditorHelper.getAvailableFields().containsKey(nameField.getId())); formEditorHelper.removeAvailableField(nameField); assertFalse(formEditorHelper.getAvailableFields().containsKey(nameField.getId())); }
|
FormEditorHelper { @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }
|
@Test public void testDestroy() { formEditorHelper.destroy(); verify(editorFieldLayoutComponents).destroyAll(); }
|
ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); void show(FormModelerContent content, Command onClose); @Override FormModel getFormModel(); @Override void close(); }
|
@Test public void testShowWithModelError() { content.setError(mock(FormModelerContentError.class)); presenter.show(content, command); }
@Test public void testShowEmptySynchronization() { presenter.show(content, command); verify(view, never()).show(); }
|
SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); }
|
@Test public void testListBoxWithExistingDefaultValue() { when(field.getDefaultValue()).thenReturn(VAL_2); SelectorData<String> data = provider.getSelectorData(context); doTestVerifications(data); assertNotNull(data.getSelectedValue()); assertEquals(VAL_2, data.getSelectedValue()); }
@Test public void testListBoxWithoutDefaultValue() { SelectorData<String> data = provider.getSelectorData(context); doTestVerifications(data); assertNull(data.getSelectedValue()); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testLoad() { loadContent(); verify(layoutEditorMock).loadLayout(content.getDefinition().getLayoutTemplate()); verify(view).init(presenter); verify(view).setupLayoutEditor(layoutEditorMock); }
@Test public void testDataObjectsFields() { loadContent(); testAddRemoveDataTypeFields(); testDataTypeFieldProperties(); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testMayClose() { testLoad(); assertTrue(presenter.onMayClose()); verify(view, never()).confirmClose(); testOnRemoveComponentWithContext(); assertFalse(presenter.onMayClose()); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testRemoveAllDraggableGroupComponent() { loadContent(); addAllFields(); when(layoutDragComponentPaletteMock.hasDraggableComponent(anyString(), anyString())).thenReturn(true); List<FieldDefinition> fieldList = presenter.getFormDefinition().getFields(); presenter.removeAllDraggableGroupComponent(fieldList); verify(translationService, times(1)).getTranslation(FormEditorConstants.FormEditorPresenterModelFields); verify(layoutDragComponentPaletteMock, times(fieldList.size())).removeDraggableComponent(anyString(), anyString()); }
|
DecisionServiceSVGShapeView extends SVGShapeViewImpl { public double getDividerLineY() { return divider.getY(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); }
|
@Test public void testGetDividerLineY() { assertThat(view.getDividerLineY()).isEqualTo(0.0); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testAddAllDraggableGroupComponent() { loadContent(); List<FieldDefinition> fieldList = presenter.getFormDefinition().getFields(); presenter.addAllDraggableGroupComponent(fieldList); verify(layoutDragComponentPaletteMock, times(fieldList.size())).addDraggableComponent(anyString(), anyString(), any()); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testDestroy() { loadContent(); presenter.destroy(); verify(editorFieldLayoutComponents).destroyAll(); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testGetFormTemplate() { loadContent(); presenter.getFormTemplate(); verify(layoutEditorMock).getLayout(); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testSave() { loadContent(); presenter.editorHelper.getContent().getDefinition().setLayoutTemplate(mock(LayoutTemplate.class)); presenter.save(""); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testGetTitleText() { loadContent(); presenter.getTitleText(); verify(translationService).format(anyString(), any()); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testMakeMenuBar() { doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); loadContent(); verify(menuBuilderMock).addSave(any(MenuItem.class)); verify(menuBuilderMock).addCopy(any(Command.class)); verify(menuBuilderMock).addRename(any(Command.class)); verify(menuBuilderMock).addDelete(any(Command.class)); verify(menuBuilderMock).addNewTopLevelMenu(alertsButtonMenuItem); verify(menuBuilderMock).addNewTopLevelMenu(downloadMenuItem); presenter.getMenus(Assert::assertNotNull); verify(menuBuilderMock, atLeastOnce()).build(); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testSafeRenameDirtySaving() { FormEditorPresenter presenterSpy = triggerSafeRename(true, true); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(true)); }
@Test public void testSafeRenameDirtyNotSaving() { FormEditorPresenter presenterSpy = triggerSafeRename(true, false); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(false)); }
@Test public void testSafeRenameNotDirty() { FormEditorPresenter presenterSpy = triggerSafeRename(false, false); verify(view, never()).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(false)); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testSafeCopyDirtySaving() { FormEditorPresenter presenterSpy = triggerSafeCopy(true, true); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(true)); }
@Test public void testSafeCopyDirtyNotSaving() { FormEditorPresenter presenterSpy = triggerSafeCopy(true, false); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(false)); }
@Test public void testSafeCopyNotDirty() { FormEditorPresenter presenterSpy = triggerSafeCopy(false, false); verify(view, never()).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(false)); }
|
DecisionServiceSVGShapeView extends SVGShapeViewImpl { public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); }
|
@Test public void testSetDividerLineY() { view.setDividerLineY(50.0); assertThat(getMoveDividerControlHandle().getControl().getY()).isEqualTo(50.0); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testRenameCommand() { loadContent(); FormEditorPresenter presenterSpy = spy(presenter); FileNameAndCommitMessage details = mock(FileNameAndCommitMessage.class); when(renamePopUpPresenter.getView()).thenReturn(mock(RenamePopUpPresenter.View.class)); doNothing().when(presenterSpy).doLoadContent(any(FormModelerContent.class)); presenterSpy.renameCommand(details, true); verify(view).showBusyIndicator(anyString()); verify(presenterSpy).getRenameErrorCallback(any(RenamePopUpPresenter.View.class)); verify(presenterSpy).getRenameSuccessCallback(any(RenamePopUpPresenter.View.class)); }
|
FormEditorPresenter extends KieEditor<FormModelerContent> { public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }
|
@Test public void testOnLockStatusChange() { loadContent(); FormEditorPresenter presenterSpy = spy(presenter); UpdatedLockStatusEvent updatedLockStatusEvent = new UpdatedLockStatusEvent(versionRecordManager.getCurrentPath(), true,false); presenterSpy.onLockStatusChange(updatedLockStatusEvent); verify(layoutEditorMock).lock(); updatedLockStatusEvent = new UpdatedLockStatusEvent(versionRecordManager.getCurrentPath(), false, false); presenterSpy.onLockStatusChange(updatedLockStatusEvent); verify(layoutEditorMock).unlock(); }
|
DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters); }
|
@Test public void testGenerateContextForModel() { StaticModelFormRenderingContext context = dynamicFormModelGenerator.getContextForModel(model); assertNotNull(context); assertNotNull(context.getRootForm()); assertEquals(3, context.getAvailableForms().size()); context.getAvailableForms().forEach((id, form) -> { testGeneratedForm(form, id); }); }
@Test public void testGenerateContextForModelWithFilters() { FormElementFilter nameFilter = new FormElementFilter("name", o -> true); FormElementFilter lastNameFilter = new FormElementFilter("lastName", o -> false); FormElementFilter addressStreetFilter = new FormElementFilter("address.street", o -> true); FormElementFilter addressNumFilter = new FormElementFilter("address.number", o -> false); StaticModelFormRenderingContext context = dynamicFormModelGenerator.getContextForModel(model, nameFilter, lastNameFilter, addressStreetFilter, addressNumFilter); assertEquals(3, context.getAvailableForms().size()); FormDefinition rootForm = context.getRootForm(); assertNotNull(rootForm); assertEquals(rootForm.getFields().size(), rootForm.getLayoutTemplate().getRows().size()); assertNotNull(rootForm.getFieldByBinding("name")); assertNull(rootForm.getFieldByBinding("lastName")); FormDefinition addressForm = context.getAvailableForms().get(Address.class.getName()); assertNotNull(addressForm); assertEquals(addressForm.getFields().size(), addressForm.getLayoutTemplate().getRows().size()); assertNotNull(addressForm.getFieldByBinding("street")); assertNull(addressForm.getFieldByBinding("number")); }
|
FormGeneratorDriver implements LayoutGeneratorDriver { @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); }
|
@Test public void testCreateComponent() { HTMLElement column = mock(HTMLElement.class); LayoutComponent layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); driver.createComponent(column, layoutComponent); verify(beanManager).lookupBeans(anyString()); verify(instance).select(eq(FieldLayoutComponent.class)); verify(wrapperWidgetUtil).getWidget(same(driver), any(HTMLElement.class)); Assertions.assertThat(driver.getLayoutFields()) .hasSize(1); FieldLayoutComponent fieldLayoutComponent = driver.getLayoutFields().get(0); verify(fieldLayoutComponent).init(eq(context), any()); verify(fieldLayoutComponent).getShowWidget(any()); layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); driver.createComponent(column, layoutComponent); verify(beanManager, times(1)).lookupBeans(anyString()); verify(instance, times(2)).select(eq(FieldLayoutComponent.class)); verify(wrapperWidgetUtil, times(2)).getWidget(same(driver), any(HTMLElement.class)); Assertions.assertThat(driver.getLayoutFields()) .hasSize(2); fieldLayoutComponent = driver.getLayoutFields().get(1); verify(fieldLayoutComponent).init(eq(context), any()); verify(fieldLayoutComponent).getShowWidget(any()); }
|
FormGeneratorDriver implements LayoutGeneratorDriver { @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); }
|
@Test public void testGetComponentPart() { testCreateComponent(); HTMLElement column = mock(HTMLElement.class); LayoutComponent layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); Optional<IsWidget> result = driver.getComponentPart(column, layoutComponent, ""); Assert.assertTrue(result.isPresent()); verify(wrapperWidgetUtil, times(3)).getWidget(same(driver), any(HTMLElement.class)); FieldLayoutComponent fieldLayoutComponent = driver.getLayoutFields().get(0); verify(fieldLayoutComponent).getContentPart(eq(""), any()); }
|
FormGeneratorDriver implements LayoutGeneratorDriver { public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); }
|
@Test public void testClear() { driver.clear(); verify(instance).destroyAll(); verify(wrapperWidgetUtil).clear(same(driver)); }
|
SliderFieldRenderer extends FieldRenderer<SliderBaseDefinition, SliderFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetConverterInt() { when(fieldDefinition.getStandaloneClassName()).thenReturn("int"); Converter converter = fieldRenderer.getConverter(); assertNotNull(converter); assertThat(converter, instanceOf(IntegerToDoubleConverter.class)); }
|
DecisionServiceSVGShapeView extends SVGShapeViewImpl { @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); }
|
@Test public void testResize() { view.getHandlerManager().fireEvent(new WiresResizeStepEvent(view, nodeDragMoveEvent, 0, 0, WIDTH, HEIGHT)); assertThat(getMoveDividerControlHandle().getControl().getX()).isEqualTo(WIDTH / 2); }
|
TextBoxFieldRenderer extends FieldRenderer<TextBoxBaseDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(textBox).setId(any()); verify(textBox).setName(anyString()); verify(textBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(textBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(textBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(formGroup).render(anyString(), eq(textBox), eq(fieldDefinition)); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testRender() { subFormWidget.render(context); verify(formRenderer).render(same(context)); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public Object getValue() { return formRenderer.getModel(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testGetValue() { subFormWidget.getValue(); verify(formRenderer).getModel(); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void setValue(Object value) { formRenderer.bind(value); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testSetValue() { final Object value = new Object(); subFormWidget.setValue(value); verify(formRenderer).bind(same(value)); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void clear() { formRenderer.unBind(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testClear() { subFormWidget.clear(); verify(formRenderer).unBind(); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void flush() { formRenderer.flush(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testFlush() { subFormWidget.flush(); verify(formRenderer).flush(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.