@org.mockito.Captor - java examples

Here are the examples of the java api @org.mockito.Captor taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

155 Examples 7

18 View Complete Implementation : CreateOrUpdatePremiumListCommandTestCase.java
Copyright Apache License 2.0
Author : google
/**
 * Base clreplaced for common testing setup for create and update commands for Premium Lists.
 */
public abstract clreplaced CreateOrUpdatePremiumListCommandTestCase<T extends CreateOrUpdatePremiumListCommand> extends CommandTestCase<T> {

    @Captor
    ArgumentCaptor<ImmutableMap<String, String>> urlParamCaptor;

    @Captor
    ArgumentCaptor<byte[]> requestBodyCaptor;

    static String generateInputData(String premiumTermsPath) throws Exception {
        return Files.asCharSource(new File(premiumTermsPath), StandardCharsets.UTF_8).read();
    }

    void verifySentParams(AppEngineConnection connection, String path, ImmutableMap<String, String> parameterMap) throws Exception {
        verify(connection).sendPostRequest(eq(path), urlParamCaptor.capture(), eq(MediaType.FORM_DATA), requestBodyCaptor.capture());
        replacedertThat(new ImmutableMap.Builder<String, String>().putAll(urlParamCaptor.getValue()).putAll(UriParameters.parse(new String(requestBodyCaptor.getValue(), UTF_8)).entries()).build()).containsExactlyEntriesIn(parameterMap);
    }
}

18 View Complete Implementation : RemovePresenterTest.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * Unit tests for {@link org.eclipse.che.ide.ext.svn.client.add.AddPresenter}.
 */
public clreplaced RemovePresenterTest extends BaseSubversionPresenterTest {

    @Captor
    private ArgumentCaptor<AsyncRequestCallback<CLIOutputResponse>> asyncRequestCallbackStatusCaptor;

    private RemovePresenter presenter;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        presenter = new RemovePresenter(appContext, dtoUnmarshallerFactory, eventBus, notificationManager, rawOutputPresenter, constants, service, workspaceAgent, projectExplorerPart);
    }

    @Test
    public void testAddNothingSelected() throws Exception {
    // We cannot test this since the SelectionAgent has a bug where something always appears selected
    }
}

17 View Complete Implementation : GetProjectEnvironmentsActionTest.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * @author Alexander Andrienko
 * @author Dmitry Shnurenko
 */
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced GetProjectEnvironmentsActionTest {

    private static final String SOME_STRING = "somePath";

    // variables for constructor
    @Mock
    private Provider<TemplatesContainer> templatesContainerProvider;

    @Mock
    private AppContext appContext;

    @Mock
    private ProjectServiceClient projectService;

    @Mock
    private NotificationManager notificationManager;

    @Mock
    private Provider<AsyncCallbackBuilder<RunnerEnvironmentTree>> callbackBuilderProvider;

    @Mock
    private RunnerLocalizationConstant locale;

    @Mock
    private RunnerUtil runnerUtil;

    @Mock
    private ChooseRunnerAction chooseRunnerAction;

    @Mock
    private Throwable reason;

    // callbacks for server
    @Mock
    private AsyncCallbackBuilder<RunnerEnvironmentTree> asyncCallbackBuilder;

    @Mock
    private AsyncRequestCallback<RunnerEnvironmentTree> asyncRequestCallback;

    // project variables
    @Mock
    private CurrentProject project;

    @Mock
    private ProjectDescriptor projectDescriptor;

    // runner variables
    @Mock
    private TemplatesContainer panel;

    @Mock
    private List<RunnerEnvironmentLeaf> environmentLeaves;

    @Mock
    private List<Environment> environments;

    @Mock
    private RunnerEnvironmentTree result;

    @Mock
    private CurrentProject currentProject;

    @Mock
    private ProjectDescriptor descriptor;

    @Mock
    private Environment environment;

    // captors
    @Captor
    private ArgumentCaptor<FailureCallback> failedCallBackCaptor;

    @Captor
    private ArgumentCaptor<SuccessCallback<RunnerEnvironmentTree>> successCallBackCaptor;

    private GetProjectEnvironmentsAction action;

    @Before
    public void setUp() {
        action = new GetProjectEnvironmentsAction(appContext, projectService, notificationManager, callbackBuilderProvider, locale, runnerUtil, chooseRunnerAction, templatesContainerProvider);
        when(templatesContainerProvider.get()).thenReturn(panel);
        // preparing callbacks for server
        when(appContext.getCurrentProject()).thenReturn(project);
        when(project.getRunner()).thenReturn(SOME_STRING);
        when(callbackBuilderProvider.get()).thenReturn(asyncCallbackBuilder);
        when(asyncCallbackBuilder.unmarshaller(RunnerEnvironmentTree.clreplaced)).thenReturn(asyncCallbackBuilder);
        when(asyncCallbackBuilder.failure(any(FailureCallback.clreplaced))).thenReturn(asyncCallbackBuilder);
        when(panel.addEnvironments(result, PROJECT)).thenReturn(Arrays.asList(environment));
        when(environment.getId()).thenReturn(SOME_STRING);
        when(asyncCallbackBuilder.success(Matchers.<SuccessCallback<RunnerEnvironmentTree>>anyObject())).thenReturn(asyncCallbackBuilder);
        when(asyncCallbackBuilder.build()).thenReturn(asyncRequestCallback);
        // preparing project data
        when(project.getProjectDescription()).thenReturn(projectDescriptor);
        when(projectDescriptor.getPath()).thenReturn(SOME_STRING);
        when(runnerUtil.hasRunPermission()).thenReturn(true);
    }

    @Test
    public void shouldNotPerformWhenCurrentProjectIsNull() {
        when(appContext.getCurrentProject()).thenReturn(null);
        action.perform();
        verify(appContext).getCurrentProject();
        verifyNoMoreInteractions(appContext, projectService, notificationManager, callbackBuilderProvider, locale, runnerUtil, chooseRunnerAction, templatesContainerProvider, project);
    }

    @Test
    public void shouldNotPerformWhenCurrentProjectIsNotNullAndProjectDoesNotHavePermission() {
        when(runnerUtil.hasRunPermission()).thenReturn(false);
        action.perform();
        verify(appContext).getCurrentProject();
        verify(runnerUtil).hasRunPermission();
        verifyNoMoreInteractions(appContext, projectService, notificationManager, callbackBuilderProvider, locale, runnerUtil, chooseRunnerAction, templatesContainerProvider, project);
    }

    @Test
    public void shouldPerformFailure() {
        String errorMessage = "error message";
        when(locale.customRunnerGetEnvironmentFailed()).thenReturn(errorMessage);
        action.perform();
        verify(appContext).getCurrentProject();
        verify(asyncCallbackBuilder).failure(failedCallBackCaptor.capture());
        FailureCallback failureCallback = failedCallBackCaptor.getValue();
        failureCallback.onFailure(reason);
        verify(locale).customRunnerGetEnvironmentFailed();
        verify(notificationManager).showError(errorMessage);
        verify(projectService).getRunnerEnvironments(SOME_STRING, asyncRequestCallback);
    }

    @Test
    public void shouldPerformSuccessWithToRunnerEnvironment() {
        when(appContext.getCurrentProject()).thenReturn(currentProject);
        when(currentProject.getProjectDescription()).thenReturn(descriptor);
        when(currentProject.getRunner()).thenReturn(SOME_STRING);
        when(descriptor.getPath()).thenReturn(SOME_STRING);
        when(descriptor.getType()).thenReturn(SOME_STRING);
        action.perform();
        verify(appContext).getCurrentProject();
        verify(asyncCallbackBuilder).success(successCallBackCaptor.capture());
    }

    @Test
    public void shouldPerformSuccessWithToRunnerEnvironmentButDefaultRunnerIsNotExist() {
        when(appContext.getCurrentProject()).thenReturn(currentProject);
        when(currentProject.getProjectDescription()).thenReturn(descriptor);
        when(currentProject.getRunner()).thenReturn(SOME_STRING + 1);
        when(descriptor.getPath()).thenReturn(SOME_STRING);
        when(descriptor.getType()).thenReturn(SOME_STRING);
        action.perform();
        verify(appContext).getCurrentProject();
        verify(asyncCallbackBuilder).success(successCallBackCaptor.capture());
    }
}

17 View Complete Implementation : CareBehaviorListControllerTest.java
Copyright Apache License 2.0
Author : arcus-smart-home
public clreplaced CareBehaviorListControllerTest extends MockClientTestCase {

    SettableModelSource<SubsystemModel> source;

    CareBehaviorListController.Callback callback;

    @Captor
    ArgumentCaptor<List<CareBehaviorModel>> behaviorArgumentCaptor;

    @Captor
    ArgumentCaptor<Throwable> behaviorTemplateErrorCaptor;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        source = new SettableModelSource<>();
        callback = Mockito.mock(CareBehaviorListController.Callback.clreplaced);
        expectRequestOfType(CareSubsystem.ListBehaviorsRequest.NAME).andRespondFromPath("subsystems/care/listBehaviorsResponse.json");
        expectRequestOfType(CareSubsystem.ListBehaviorTemplatesRequest.NAME).andRespondFromPath("subsystems/care/listBehaviorTemplatesResponse.json");
    }

    @Test
    public void showBehaviors() throws Exception {
        CareBehaviorListController controller = new CareBehaviorListController(source);
        source.set((SubsystemModel) Fixtures.loadModel("subsystems/care/subsystemAlarmReadyON.json"));
        controller.setCallback(callback);
        Mockito.verify(callback, Mockito.times(1)).showBehaviors(behaviorArgumentCaptor.capture());
        List<CareBehaviorModel> behaviors = behaviorArgumentCaptor.getValue();
        replacedertNotNull(behaviors);
        replacedertFalse(behaviors.isEmpty());
        Mockito.verifyNoMoreInteractions(callback);
        Fixtures.deleteModel(source.get().getAddress());
        replacedertFalse(controller.behaviorsLoaded());
        replacedertFalse(controller.templatesLoaded());
    }
}

17 View Complete Implementation : TestUnitMergeRequestApi.java
Copyright MIT License
Author : gitlab4j
public clreplaced TestUnitMergeRequestApi {

    @Mock
    private GitLabApi mockGitLabApi;

    @Mock
    private GitLabApiClient mockedGitLabApiClient;

    @Captor
    private ArgumentCaptor<MultivaluedMap<String, String>> attributeCaptor;

    private MockResponse mockedResponse;

    @Before
    public void setUp() throws Exception {
        initMocks(this);
        mockedResponse = new MockResponse(MergeRequest.clreplaced, "merge-request.json", null);
        when(mockGitLabApi.getApiClient()).thenReturn(mockedGitLabApiClient);
        when(mockedGitLabApiClient.validateSecretToken(any())).thenReturn(true);
        when(mockedGitLabApiClient.put(attributeCaptor.capture(), Mockito.<Object>any())).thenReturn(mockedResponse);
    }

    @Test
    public void whenAllArgumentsNull_thenNoAttributesSent() throws Exception {
        new MergeRequestApi(mockGitLabApi).updateMergeRequest(1, 2, null, null, null, null, null, null, null, null, null, null, null);
        replacedertEquals(0, attributeCaptor.getValue().size());
    }

    @Test
    public void falseBooleansAreSerializedCorrectly() throws Exception {
        new MergeRequestApi(mockGitLabApi).updateMergeRequest(1, 2, null, null, null, null, null, null, null, null, null, null, false);
        replacedertThat(attributeCaptor.getValue(), hasEntry("allow_collaboration", Collections.singletonList("false")));
    }

    @Test
    public void trueBooleansAreSerializedCorrectly() throws Exception {
        new MergeRequestApi(mockGitLabApi).updateMergeRequest(1, 2, null, null, null, null, null, null, null, null, null, null, true);
        replacedertThat(attributeCaptor.getValue(), hasEntry("allow_collaboration", Collections.singletonList("true")));
    }
}

17 View Complete Implementation : LightsNSwitchesDashCardControllerTest.java
Copyright Apache License 2.0
Author : arcus-smart-home
public clreplaced LightsNSwitchesDashCardControllerTest extends MockClientTestCase {

    LightsNSwitchesDashCardController controller;

    SettableModelSource<SubsystemModel> source;

    @Captor
    ArgumentCaptor<LightsNSwitchesSummary> summaryArgumentCaptor;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        source = new SettableModelSource<>();
        controller = new LightsNSwitchesDashCardController(source);
    }

    @Test
    public void loadDashboardCard() throws Exception {
        source.set((SubsystemModel) Fixtures.loadModel("subsystems/lightsnswitches/subsystem.json"));
        LightsNSwitchesDashCardController.Callback callback = Mockito.mock(LightsNSwitchesDashCardController.Callback.clreplaced);
        controller.setCallback(callback);
        Mockito.verify(callback, Mockito.times(1)).showSummary(summaryArgumentCaptor.capture());
        replacedertEquals(2, summaryArgumentCaptor.getValue().getLightsOn());
        replacedertEquals(2, summaryArgumentCaptor.getValue().getSwitchesOn());
        replacedertEquals(0, summaryArgumentCaptor.getValue().getDimmersOn());
    }

    @Test
    public void loadDashboardLearnMoreCard() throws Exception {
        source.set((SubsystemModel) Fixtures.loadModel("subsystems/lightsnswitches/subsystem_no_devs.json"));
        LightsNSwitchesDashCardController.Callback callback = Mockito.mock(LightsNSwitchesDashCardController.Callback.clreplaced);
        controller.setCallback(callback);
        Mockito.verify(callback, Mockito.times(0)).showSummary(Mockito.any(LightsNSwitchesSummary.clreplaced));
        Mockito.verify(callback, Mockito.times(1)).showLearnMore();
    }
}

17 View Complete Implementation : AuthDomainAuditorTest.java
Copyright BSD 3-Clause "New" or "Revised" License
Author : all-of-us
@RunWith(SpringRunner.clreplaced)
public clreplaced AuthDomainAuditorTest {

    private static final long USER_ID = 101L;

    @Autowired
    private AuthDomainAuditor authDomainAuditAdapter;

    @MockBean
    private ActionAuditService mockActionAuditService;

    @Captor
    private ArgumentCaptor<ActionAuditEvent> eventCaptor;

    @TestConfiguration
    @Import({ AuthDomainAuditorImpl.clreplaced, ActionAuditTestConfig.clreplaced })
    static clreplaced Config {
    }

    @Test
    public void testFires() {
        authDomainAuditAdapter.fireSetAccountDisabledStatus(USER_ID, true, false);
        verify(mockActionAuditService).send(eventCaptor.capture());
        final ActionAuditEvent event = eventCaptor.getValue();
        replacedertThat(event.getTimestamp()).isEqualTo(ActionAuditTestConfig.INSTANT.toEpochMilli());
        replacedertThat(event.getAgentType()).isEqualTo(AgentType.ADMINISTRATOR);
        replacedertThat(event.getAgentId()).isEqualTo(ActionAuditTestConfig.ADMINISTRATOR_USER_ID);
        replacedertThat(event.getAgentEmailMaybe()).contains(ActionAuditTestConfig.ADMINISTRATOR_EMAIL);
        replacedertThat(event.getActionId()).contains(ActionAuditTestConfig.ACTION_ID);
        replacedertThat(event.getActionType()).isEqualTo(ActionType.EDIT);
        replacedertThat(event.getTargetType()).isEqualTo(TargetType.ACCOUNT);
        replacedertThat(event.getTargetPropertyMaybe()).isEqualTo(AccountTargetProperty.IS_ENABLED.getPropertyName());
        replacedertThat(event.getTargetIdMaybe()).isEqualTo(USER_ID);
        replacedertThat(event.getPreviousValueMaybe()).isEqualTo(AccountDisabledStatus.ENABLED.getValueName());
        replacedertThat(event.getNewValueMaybe()).isEqualTo(AccountDisabledStatus.DISABLED.getValueName());
    }
}

17 View Complete Implementation : CaptorAnnotationAutoboxingTest.java
Copyright GNU General Public License v2.0
Author : SpoonLabs
// see issue 188
public clreplaced CaptorAnnotationAutoboxingTest extends TestBase {

    interface Fun {

        void doFun(double prmitive);

        void moreFun(int howMuch);
    }

    @Mock
    Fun fun;

    @Captor
    ArgumentCaptor<Double> captor;

    @Test
    public void shouldAutoboxSafely() {
        // given
        fun.doFun(1.0);
        // then
        verify(fun).doFun(captor.capture());
        replacedertEquals((Double) 1.0, captor.getValue());
    }

    @Captor
    ArgumentCaptor<Integer> intCaptor;

    @Test
    public void shouldAutoboxAllPrimitives() {
        verify(fun, never()).moreFun(intCaptor.capture());
    }
}

17 View Complete Implementation : ShowProjectGitReadOnlyUrlPresenterTest.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * Testing {@link ShowProjectGitReadOnlyUrlPresenter} functionality.
 *
 * @author Andrey Plotnikov
 * @author Oleksii Orel
 */
public clreplaced ShowProjectGitReadOnlyUrlPresenterTest extends BaseTest {

    @Captor
    private ArgumentCaptor<AsyncRequestCallback<String>> asyncRequestCallbackGitReadOnlyUrlCaptor;

    @Captor
    private ArgumentCaptor<AsyncRequestCallback<List<Remote>>> asyncRequestCallbackRemoteListCaptor;

    @Mock
    private ShowProjectGitReadOnlyUrlView view;

    private ShowProjectGitReadOnlyUrlPresenter presenter;

    @Override
    public void disarm() {
        super.disarm();
        presenter = new ShowProjectGitReadOnlyUrlPresenter(view, service, appContext, constant, console, notificationManager, dtoUnmarshallerFactory);
    }

    @Test
    public void getGitReadOnlyUrlAsyncCallbackIsSuccess() throws Exception {
        presenter.showDialog();
        verify(service).getGitReadOnlyUrl((ProjectDescriptor) anyObject(), asyncRequestCallbackGitReadOnlyUrlCaptor.capture());
        AsyncRequestCallback<String> callback = asyncRequestCallbackGitReadOnlyUrlCaptor.getValue();
        Method onSuccess = GwtReflectionUtils.getMethod(callback.getClreplaced(), "onSuccess");
        onSuccess.invoke(callback, LOCALE_URI);
        verify(appContext).getCurrentProject();
        verify(service).getGitReadOnlyUrl(eq(rootProjectDescriptor), (AsyncRequestCallback<String>) anyObject());
        verify(view).setLocaleUrl(eq(LOCALE_URI));
    }

    @Test
    public void getGitReadOnlyUrlAsyncCallbackIsFailed() throws Exception {
        presenter.showDialog();
        verify(service).getGitReadOnlyUrl((ProjectDescriptor) anyObject(), asyncRequestCallbackGitReadOnlyUrlCaptor.capture());
        AsyncRequestCallback<String> callback = asyncRequestCallbackGitReadOnlyUrlCaptor.getValue();
        Method onSuccess = GwtReflectionUtils.getMethod(callback.getClreplaced(), "onFailure");
        onSuccess.invoke(callback, mock(Throwable.clreplaced));
        verify(appContext).getCurrentProject();
        verify(service).getGitReadOnlyUrl(eq(rootProjectDescriptor), (AsyncRequestCallback<String>) anyObject());
        verify(notificationManager).showNotification((Notification) anyObject());
        verify(console).printError(anyString());
        verify(constant).initFailed();
    }

    @Test
    public void getGitRemoteListAsyncCallbackIsSuccess() throws Exception {
        final List<Remote> remotes = new ArrayList<>();
        remotes.add(mock(Remote.clreplaced));
        presenter.showDialog();
        verify(service).remoteList((ProjectDescriptor) anyObject(), anyString(), anyBoolean(), asyncRequestCallbackRemoteListCaptor.capture());
        AsyncRequestCallback<List<Remote>> callback = asyncRequestCallbackRemoteListCaptor.getValue();
        Method onSuccess = GwtReflectionUtils.getMethod(callback.getClreplaced(), "onSuccess");
        onSuccess.invoke(callback, remotes);
        verify(appContext).getCurrentProject();
        verify(service).remoteList(eq(rootProjectDescriptor), anyString(), eq(true), (AsyncRequestCallback<List<Remote>>) anyObject());
        verify(view).setRemotes((List<Remote>) anyObject());
    }

    @Test
    public void getGitRemoteListAsyncCallbackIsFailed() throws Exception {
        final List<Remote> remotes = new ArrayList<>();
        remotes.add(mock(Remote.clreplaced));
        presenter.showDialog();
        verify(service).remoteList((ProjectDescriptor) anyObject(), anyString(), anyBoolean(), asyncRequestCallbackRemoteListCaptor.capture());
        AsyncRequestCallback<List<Remote>> callback = asyncRequestCallbackRemoteListCaptor.getValue();
        Method onSuccess = GwtReflectionUtils.getMethod(callback.getClreplaced(), "onFailure");
        onSuccess.invoke(callback, mock(Throwable.clreplaced));
        verify(appContext).getCurrentProject();
        verify(service).remoteList(eq(rootProjectDescriptor), anyString(), eq(true), (AsyncRequestCallback<List<Remote>>) anyObject());
        verify(view).setRemotes(null);
        verify(console).printError(anyString());
        verify(notificationManager).showNotification((Notification) anyObject());
    }

    @Test
    public void testOnCloseClicked() throws Exception {
        presenter.onCloseClicked();
        verify(view).close();
    }
}

17 View Complete Implementation : BPMNProjectBaseSessionDiagramHandlerTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public abstract clreplaced BPMNProjectBaseSessionDiagramHandlerTest<H extends BPMNProjectBaseSessionDiagramHandler> {

    private static final String SVG = "SVG";

    @Mock
    protected BPMNDiagramResourceType bpmnDiagramResourceType;

    @Mock
    protected ClientDiagramService diagramService;

    @Mock
    protected CanvasFileExport canvasExport;

    @Mock
    protected EventSourceMock<NotificationEvent> notificationEvent;

    @Mock
    protected ClientTranslationService translationService;

    @Mock
    protected ProjectDiagram projectDiagram;

    @Mock
    protected ProjectMetadata projectMetadata;

    @Mock
    protected Path path;

    @Mock
    protected EditorSession editorSession;

    @Mock
    protected AbstractCanvasHandler canvasHandler;

    @Mock
    protected SelectionControl selectionControl;

    @Captor
    protected ArgumentCaptor<ServiceCallback<Path>> serviceCallbackCaptor;

    protected H handler;

    @Before
    @SuppressWarnings("unchecked")
    public void setUp() {
        when(projectDiagram.getMetadata()).thenReturn(projectMetadata);
        when(projectMetadata.getPath()).thenReturn(path);
        when(editorSession.getCanvasHandler()).thenReturn(canvasHandler);
        when(canvasHandler.getDiagram()).thenReturn(projectDiagram);
        when(editorSession.getSelectionControl()).thenReturn(selectionControl);
        when(canvasExport.exportToSvg(canvasHandler)).thenReturn(SVG);
        handler = createHandler();
    }

    protected abstract H createHandler();

    @Test
    public void testAcceptsProjectDiagramBPMNResource() {
        when(bpmnDiagramResourceType.accept(path)).thenReturn(true);
        replacedertTrue(handler.accepts(projectDiagram));
    }

    @Test
    public void testAcceptsProjectDiagramNonBPMNResource() {
        when(bpmnDiagramResourceType.accept(path)).thenReturn(false);
        replacedertFalse(handler.accepts(projectDiagram));
    }

    @Test
    public void testAcceptsNonProjectDiagram() {
        replacedertFalse(handler.accepts(mock(Diagram.clreplaced)));
    }

    protected void verifySaveOrUpdateSuccessful() {
        verify(selectionControl).clearSelection();
        verify(diagramService).saveOrUpdateSvg(eq(path), eq(SVG), serviceCallbackCaptor.capture());
        serviceCallbackCaptor.getValue().onSuccess(path);
    }

    protected void verifySaveOrUpdateWithErrors() {
        verify(selectionControl).clearSelection();
        when(translationService.getValue(EditorGenerateSvgFileError)).thenReturn(EditorGenerateSvgFileError);
        verify(diagramService).saveOrUpdateSvg(eq(path), eq(SVG), serviceCallbackCaptor.capture());
        serviceCallbackCaptor.getValue().onError(new ClientRuntimeError("some error"));
        verify(notificationEvent).fire(new NotificationEvent(EditorGenerateSvgFileError, NotificationEvent.NotificationType.ERROR));
    }

    @SuppressWarnings("unchecked")
    protected void verifyDoNothing() {
        verify(selectionControl, never()).clearSelection();
        verify(canvasExport, never()).exportToSvg(any(AbstractCanvasHandler.clreplaced));
        verify(diagramService, never()).saveOrUpdateSvg(any(Path.clreplaced), any(String.clreplaced), any(ServiceCallback.clreplaced));
    }
}

17 View Complete Implementation : DefaultOutputWriterTest.java
Copyright GNU Affero General Public License v3.0
Author : CeON
/**
 * @author madryk
 */
public clreplaced DefaultOutputWriterTest {

    private DefaultOutputWriter outputWriter = new DefaultOutputWriter();

    @Mock
    private JavaPairRDD<MatchableEnreplacedy, IdWithSimilarity> matchedCitations;

    @Mock
    private JavaPairRDD<TextWithBytesWritable, Text> mappedMatchedCitations;

    @Captor
    private ArgumentCaptor<PairFunction<Tuple2<MatchableEnreplacedy, IdWithSimilarity>, TextWithBytesWritable, Text>> mapToWritableFunction;

    @BeforeMethod
    public void setup() {
        MockitoAnnotations.initMocks(this);
    }

    // ------------------------ TESTS --------------------------
    @Test
    public void writeMatchedCitations() throws Exception {
        // given
        doReturn(mappedMatchedCitations).when(matchedCitations).mapToPair(any());
        // execute
        outputWriter.writeMatchedCitations(matchedCitations, "/output/path");
        // replacedert
        verify(matchedCitations).mapToPair(mapToWritableFunction.capture());
        replacedertMapToWritableFunction(mapToWritableFunction.getValue());
        verify(mappedMatchedCitations).saveAsNewAPIHadoopFile("/output/path", TextWithBytesWritable.clreplaced, Text.clreplaced, SequenceFileOutputFormat.clreplaced);
    }

    // ------------------------ PRIVATE --------------------------
    private void replacedertMapToWritableFunction(PairFunction<Tuple2<MatchableEnreplacedy, IdWithSimilarity>, TextWithBytesWritable, Text> function) throws Exception {
        MatchableEnreplacedy enreplacedy = MatchableEnreplacedy.fromParameters("some_cit_id", "John Doe", null, "Some replacedle", null, null, null);
        IdWithSimilarity idWithSimilarity = new IdWithSimilarity("some_doc_id", 0.345);
        Tuple2<MatchableEnreplacedy, IdWithSimilarity> matchedCitation = new Tuple2<>(enreplacedy, idWithSimilarity);
        Tuple2<TextWithBytesWritable, Text> matchedCitationWritable = function.call(matchedCitation);
        replacedertEquals(matchedCitationWritable._1.text().toString(), "some_cit_id");
        replacedertEquals(matchedCitationWritable._1.bytes().copyBytes(), enreplacedy.data().toByteArray());
        replacedertEquals(matchedCitationWritable._2.toString(), "0.345:some_doc_id");
    }
}

17 View Complete Implementation : PropertyEditorPresenterTest.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * Unit tests for {@link org.eclipse.che.ide.ext.svn.client.property.PropertyEditorPresenter}.
 *
 * @author Vladyslav Zhukovskyi
 */
public clreplaced PropertyEditorPresenterTest extends BaseSubversionPresenterTest {

    @Captor
    private ArgumentCaptor<AsyncRequestCallback<CLIOutputResponse>> asyncRequestCallbackStatusCaptor;

    private PropertyEditorPresenter presenter;

    @Mock
    PropertyEditorView view;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        presenter = new PropertyEditorPresenter(appContext, eventBus, rawOutputPresenter, workspaceAgent, projectExplorerPart, view, service, dtoUnmarshallerFactory, notificationManager, constants);
    }

    @Test
    public void testViewShouldBeShowed() throws Exception {
        presenter.showEditor();
        verify(view).onShow();
    }
}

17 View Complete Implementation : ProcessConverterDelegateTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced ProcessConverterDelegateTest {

    @Captor
    private ArgumentCaptor<Node<View<? extends BPMNViewDefinition>, ?>> nodeCaptor;

    @Test
    public void convertDockedEdges() {
        GraphNodeStoreImpl nodes = new GraphNodeStoreImpl();
        GraphImpl g = new GraphImpl("g", nodes);
        NodeImpl<Object> root = new NodeImpl<>("root");
        BPMNDiagramImpl bpmnDiagram = new BPMNDiagramImpl();
        root.setContent(new ViewImpl<>(bpmnDiagram, Bounds.create()));
        g.addNode(root);
        NodeImpl<Object> n = new NodeImpl<>("n");
        EmbeddedSubprocess subProcessNode = new EmbeddedSubprocess();
        n.setContent(new ViewImpl<>(subProcessNode, Bounds.create()));
        g.addNode(n);
        NodeImpl<Object> e = new NodeImpl<>("e");
        IntermediateErrorEventCatching intermediateErrorEventCatching = new IntermediateErrorEventCatching();
        e.setContent(new ViewImpl<>(intermediateErrorEventCatching, Bounds.create()));
        g.addNode(e);
        EdgeImpl<Object> edge = new EdgeImpl<>("edge");
        Dock dock = new Dock();
        edge.setContent(dock);
        n.getOutEdges().add(edge);
        edge.setSourceNode(n);
        e.getInEdges().add(edge);
        edge.setTargetNode(e);
        DefinitionsBuildingContext ctx = new DefinitionsBuildingContext(g);
        PropertyWriterFactory pwFactory = new PropertyWriterFactory();
        ConverterFactory factory = new ConverterFactory(ctx, pwFactory);
        MyProcessConverter abstractProcessConverter = new MyProcessConverter(factory);
        ProcessPropertyWriter p = pwFactory.of(bpmn2.createProcess());
        replacedertThatCode(() -> {
            abstractProcessConverter.convertChildNodes(p, ctx);
            abstractProcessConverter.convertEdges(p, ctx);
        }).doesNotThrowAnyException();
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testPostConvertNodes() {
        TestingGraphMockHandler graphTestHandler = new TestingGraphMockHandler();
        BPMNDiagramImpl bpmnDiagram = new BPMNDiagramImpl();
        StartNoneEvent level0StartNode = new StartNoneEvent();
        EndNoneEvent level0EndNode = new EndNoneEvent();
        UserTask level0Node1 = new UserTask();
        UserTask level0Node2 = new UserTask();
        EmbeddedSubprocess level1SubProcess1 = new EmbeddedSubprocess();
        ScriptTask level1Node1 = new ScriptTask();
        IntermediateSignalEventThrowing level1Node2 = new IntermediateSignalEventThrowing();
        AdHocSubprocess level2SubProcess1 = new AdHocSubprocess();
        BusinessRuleTask level2Node1 = new BusinessRuleTask();
        EndCompensationEvent level2Node2 = new EndCompensationEvent();
        TestingGraphInstanceBuilder2.Level2Graph level2Graph = TestingGraphInstanceBuilder2.buildLevel2Graph(graphTestHandler, bpmnDiagram, level0StartNode, level0Node1, level0Node2, level0EndNode, level1SubProcess1, level1Node1, level1Node2, level2SubProcess1, level2Node1, level2Node2);
        DefinitionsBuildingContext ctx = new DefinitionsBuildingContext(level2Graph.graph);
        PropertyWriterFactory writerFactory = new PropertyWriterFactory();
        ConverterFactory factory = spy(new ConverterFactory(ctx, writerFactory));
        FlowElementPostConverter flowElementPostConverter = mock(FlowElementPostConverter.clreplaced);
        when(factory.flowElementPostConverter()).thenReturn(flowElementPostConverter);
        MyProcessConverter abstractProcessConverter = new MyProcessConverter(factory);
        ProcessPropertyWriter processWriter = writerFactory.of(bpmn2.createProcess());
        abstractProcessConverter.postConvertChildNodes(processWriter, ctx);
        verify(flowElementPostConverter, times(10)).postConvert(anyObject(), anyObject(), nodeCaptor.capture());
        Map<String, BPMNViewDefinition> nodes = new HashMap<>();
        nodes.put(LEVEL0_START_NODE.uuid(), level0StartNode);
        nodes.put(LEVEL0_NODE1.uuid(), level0Node1);
        nodes.put(LEVEL0_NODE2.uuid(), level0Node2);
        nodes.put(LEVEL0_END_NODE.uuid(), level0EndNode);
        nodes.put(LEVEL1_SUB_PROCESS1.uuid(), level1SubProcess1);
        nodes.put(LEVEL1_NODE1.uuid(), level1Node1);
        nodes.put(LEVEL1_NODE2.uuid(), level1Node2);
        nodes.put(LEVEL2_SUB_PROCESS1.uuid(), level2SubProcess1);
        nodes.put(LEVEL2_NODE1.uuid(), level2Node1);
        nodes.put(LEVEL2_NODE2.uuid(), level2Node2);
        replacedertEquals(nodes.size(), nodeCaptor.getAllValues().size());
        nodes.entrySet().forEach(entry -> {
            Optional<Node<View<? extends BPMNViewDefinition>, ?>> processed = nodeCaptor.getAllValues().stream().filter(captured -> entry.getKey().equals(captured.getUUID())).findFirst();
            replacedertTrue("Node: " + entry.getKey() + " was not present in result", processed.isPresent());
            replacedertEquals(entry.getValue(), processed.get().getContent().getDefinition());
        });
    }

    static clreplaced MyProcessConverter extends ProcessConverterDelegate {

        public MyProcessConverter(ConverterFactory converterFactory) {
            super(converterFactory);
        }
    }
}

17 View Complete Implementation : ClusterManagerHostHealthEvaluatorTest.java
Copyright Apache License 2.0
Author : hortonworks
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced ClusterManagerHostHealthEvaluatorTest {

    private static final long CLUSTER_ID = 1;

    private static final String STACK_CRN = "STACK_CRN";

    private static final String NEW_HEALTHY = "NEW_HEALTHY";

    private static final String NEW_FAILED = "NEW_FAILED";

    private static final String OLD_FAILED = "OLD_FAILED";

    @Rule
    public ExpectedException expectedException = ExpectedException.none();

    @Mock
    private ClusterService clusterService;

    @Mock
    private HostHealthEvaluatorService hostHealthEvaluatorService;

    @Mock
    private ClusterManagerSpecificHostHealthEvaluator clusterManagerSpecificHostHealthEvaluator;

    @Mock
    private CloudbreakClientConfiguration cloudbreakClientConfiguration;

    @Mock
    private FailedNodeRepository failedNodeRepository;

    @InjectMocks
    private ClusterManagerHostHealthEvaluator underTest;

    @Mock
    private EvaluatorContext evaluatorContext;

    @Mock
    private CloudbreakInternalCrnClient cloudbreakInternalCrnClient;

    @Mock
    private CloudbreakServiceCrnEndpoints cloudbreakServiceCrnEndpoints;

    @Mock
    private AutoscaleV4Endpoint autoscaleV4Endpoint;

    @Captor
    private ArgumentCaptor<ChangedNodesReportV4Request> captor;

    @Before
    public void setUp() {
        when(evaluatorContext.getData()).thenReturn(CLUSTER_ID);
        when(hostHealthEvaluatorService.get(ClusterManagerVariant.CLOUDERA_MANAGER)).thenReturn(clusterManagerSpecificHostHealthEvaluator);
        underTest.setContext(evaluatorContext);
        when(cloudbreakClientConfiguration.cloudbreakInternalCrnClientClient()).thenReturn(cloudbreakInternalCrnClient);
        when(cloudbreakInternalCrnClient.withInternalCrn()).thenReturn(cloudbreakServiceCrnEndpoints);
        when(cloudbreakServiceCrnEndpoints.autoscaleEndpoint()).thenReturn(autoscaleV4Endpoint);
    }

    @Test
    public void shouldReportNewFailedAndHealthyNodes() {
        Cluster cluster = getCluster();
        when(clusterService.findById(CLUSTER_ID)).thenReturn(cluster);
        FailedNode oldFailedNode = getFailedNode(OLD_FAILED);
        FailedNode newHealthyNode = getFailedNode(NEW_HEALTHY);
        when(failedNodeRepository.findByClusterId(CLUSTER_ID)).thenReturn(List.of(oldFailedNode, newHealthyNode));
        when(clusterManagerSpecificHostHealthEvaluator.determineHostnamesToRecover(cluster)).thenReturn(List.of(OLD_FAILED, NEW_FAILED));
        underTest.execute();
        verify(autoscaleV4Endpoint).changedNodesReport(eq(STACK_CRN), captor.capture());
        FailedNode newFailedNode = new FailedNode();
        newFailedNode.setClusterId(CLUSTER_ID);
        newFailedNode.setName(NEW_FAILED);
        verify(failedNodeRepository).findByClusterId(CLUSTER_ID);
        verify(failedNodeRepository).saveAll(List.of(newFailedNode));
        verify(failedNodeRepository).deleteAll(List.of(newHealthyNode));
        verifyNoMoreInteractions(failedNodeRepository);
        ChangedNodesReportV4Request request = captor.getValue();
        replacedertThat(request.getNewFailedNodes(), is(List.of(NEW_FAILED)));
        replacedertThat(request.getNewHealthyNodes(), is(List.of(NEW_HEALTHY)));
    }

    @Test
    public void shouldNotUpdateFailedNodesIfErrorHappens() {
        Cluster cluster = getCluster();
        when(clusterService.findById(CLUSTER_ID)).thenReturn(cluster);
        when(clusterManagerSpecificHostHealthEvaluator.determineHostnamesToRecover(cluster)).thenReturn(List.of(NEW_FAILED));
        doThrow(new RuntimeException("API exception")).when(autoscaleV4Endpoint).changedNodesReport(anyString(), ArgumentMatchers.any());
        expectedException.expect(RuntimeException.clreplaced);
        expectedException.expectMessage("API exception");
        underTest.execute();
        verify(failedNodeRepository).findByClusterId(CLUSTER_ID);
        verifyNoMoreInteractions(failedNodeRepository);
    }

    @Test
    public void shouldNotUpdateWhenFailedNodesNotChanged() {
        Cluster cluster = getCluster();
        when(clusterService.findById(CLUSTER_ID)).thenReturn(cluster);
        FailedNode failedNode = getFailedNode(OLD_FAILED);
        when(failedNodeRepository.findByClusterId(CLUSTER_ID)).thenReturn(List.of(failedNode));
        when(clusterManagerSpecificHostHealthEvaluator.determineHostnamesToRecover(cluster)).thenReturn(List.of(OLD_FAILED));
        underTest.execute();
        verifyZeroInteractions(cloudbreakInternalCrnClient);
        verify(failedNodeRepository).findByClusterId(CLUSTER_ID);
        verifyNoMoreInteractions(failedNodeRepository);
    }

    private Cluster getCluster() {
        Cluster cluster = new Cluster();
        cluster.setStackCrn(STACK_CRN);
        ClusterManager cm = new ClusterManager();
        cm.setVariant(ClusterManagerVariant.CLOUDERA_MANAGER);
        cluster.setClusterManager(cm);
        return cluster;
    }

    private FailedNode getFailedNode(String name) {
        FailedNode failedNode = new FailedNode();
        failedNode.setClusterId(CLUSTER_ID);
        failedNode.setName(name);
        return failedNode;
    }
}

17 View Complete Implementation : SettingsServiceImplTest.java
Copyright MIT License
Author : linuxserver
public clreplaced SettingsServiceImplTest {

    @Mock
    private RestTemplate mockRestTemplate;

    @Captor
    private ArgumentCaptor<HttpEnreplacedy<String>> enreplacedyCaptor;

    @InjectMocks
    private SettingsService settingsService = new SettingsServiceImpl();

    @Before
    public void before() {
        initMocks(this);
        when(mockRestTemplate.exchange(eq("https://raw.githubusercontent.com/linuxserver/davos/LatestRelease/version.txt"), eq(HttpMethod.GET), any(HttpEnreplacedy.clreplaced), eq(String.clreplaced))).thenReturn(new ResponseEnreplacedy<String>("2.2.2", HttpStatus.OK));
    }

    @Test
    public void checkVersionShouldCallGitHub() {
        settingsService.retrieveRemoteVersion();
        verify(mockRestTemplate).exchange(eq("https://raw.githubusercontent.com/linuxserver/davos/LatestRelease/version.txt"), eq(HttpMethod.GET), enreplacedyCaptor.capture(), eq(String.clreplaced));
    }

    @Test
    public void checkVersionShouldReturnVersionFromGithub() {
        Version version = settingsService.retrieveRemoteVersion();
        replacedertThat(version.toString()).isEqualTo("2.2.2");
    }

    @Test
    public void ifRestTemplateFailsThenReturnEmptyVersion() {
        when(mockRestTemplate.exchange(eq("https://raw.githubusercontent.com/linuxserver/davos/LatestRelease/version.txt"), eq(HttpMethod.GET), any(HttpEnreplacedy.clreplaced), eq(String.clreplaced))).thenThrow(new RestClientException(""));
        Version version = settingsService.retrieveRemoteVersion();
        replacedertThat(version.toString()).isEqualTo("0.0.0");
    }
}

17 View Complete Implementation : ProcessConverterDelegateTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced ProcessConverterDelegateTest {

    @Captor
    private ArgumentCaptor<Node<View<? extends BPMNViewDefinition>, ?>> nodeCaptor;

    @Test
    public void convertDockedEdges() {
        GraphNodeStoreImpl nodes = new GraphNodeStoreImpl();
        GraphImpl g = new GraphImpl("g", nodes);
        NodeImpl<Object> root = new NodeImpl<>("root");
        BPMNDiagramImpl bpmnDiagram = new BPMNDiagramImpl();
        root.setContent(new ViewImpl<>(bpmnDiagram, Bounds.create()));
        g.addNode(root);
        NodeImpl<Object> n = new NodeImpl<>("n");
        EmbeddedSubprocess subProcessNode = new EmbeddedSubprocess();
        n.setContent(new ViewImpl<>(subProcessNode, Bounds.create()));
        g.addNode(n);
        NodeImpl<Object> e = new NodeImpl<>("e");
        IntermediateErrorEventCatching intermediateErrorEventCatching = new IntermediateErrorEventCatching();
        e.setContent(new ViewImpl<>(intermediateErrorEventCatching, Bounds.create()));
        g.addNode(e);
        EdgeImpl<Object> edge = new EdgeImpl<>("edge");
        Dock dock = new Dock();
        edge.setContent(dock);
        n.getOutEdges().add(edge);
        edge.setSourceNode(n);
        e.getInEdges().add(edge);
        edge.setTargetNode(e);
        DefinitionsBuildingContext ctx = new DefinitionsBuildingContext(g);
        PropertyWriterFactory pwFactory = new PropertyWriterFactory();
        ConverterFactory factory = new ConverterFactory(ctx, pwFactory);
        MyProcessConverter abstractProcessConverter = new MyProcessConverter(factory);
        ProcessPropertyWriter p = pwFactory.of(bpmn2.createProcess());
        replacedertThatCode(() -> {
            abstractProcessConverter.convertChildNodes(p, ctx);
            abstractProcessConverter.convertEdges(p, ctx);
        }).doesNotThrowAnyException();
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testPostConvertNodes() {
        TestingGraphMockHandler graphTestHandler = new TestingGraphMockHandler();
        BPMNDiagramImpl bpmnDiagram = new BPMNDiagramImpl();
        StartNoneEvent level0StartNode = new StartNoneEvent();
        EndNoneEvent level0EndNode = new EndNoneEvent();
        UserTask level0Node1 = new UserTask();
        UserTask level0Node2 = new UserTask();
        EmbeddedSubprocess level1SubProcess1 = new EmbeddedSubprocess();
        ScriptTask level1Node1 = new ScriptTask();
        IntermediateSignalEventThrowing level1Node2 = new IntermediateSignalEventThrowing();
        AdHocSubprocess level2SubProcess1 = new AdHocSubprocess();
        BusinessRuleTask level2Node1 = new BusinessRuleTask();
        EndCompensationEvent level2Node2 = new EndCompensationEvent();
        TestingGraphInstanceBuilder2.Level2Graph level2Graph = TestingGraphInstanceBuilder2.buildLevel2Graph(graphTestHandler, bpmnDiagram, level0StartNode, level0Node1, level0Node2, level0EndNode, level1SubProcess1, level1Node1, level1Node2, level2SubProcess1, level2Node1, level2Node2);
        DefinitionsBuildingContext ctx = new DefinitionsBuildingContext(level2Graph.graph);
        PropertyWriterFactory writerFactory = new PropertyWriterFactory();
        ConverterFactory factory = spy(new ConverterFactory(ctx, writerFactory));
        FlowElementPostConverter flowElementPostConverter = mock(FlowElementPostConverter.clreplaced);
        when(factory.flowElementPostConverter()).thenReturn(flowElementPostConverter);
        MyProcessConverter abstractProcessConverter = new MyProcessConverter(factory);
        ProcessPropertyWriter processWriter = writerFactory.of(bpmn2.createProcess());
        abstractProcessConverter.postConvertChildNodes(processWriter, ctx);
        verify(flowElementPostConverter, times(10)).postConvert(anyObject(), anyObject(), nodeCaptor.capture());
        Map<String, BPMNViewDefinition> nodes = new HashMap<>();
        nodes.put(LEVEL0_START_NODE.uuid(), level0StartNode);
        nodes.put(LEVEL0_NODE1.uuid(), level0Node1);
        nodes.put(LEVEL0_NODE2.uuid(), level0Node2);
        nodes.put(LEVEL0_END_NODE.uuid(), level0EndNode);
        nodes.put(LEVEL1_SUB_PROCESS1.uuid(), level1SubProcess1);
        nodes.put(LEVEL1_NODE1.uuid(), level1Node1);
        nodes.put(LEVEL1_NODE2.uuid(), level1Node2);
        nodes.put(LEVEL2_SUB_PROCESS1.uuid(), level2SubProcess1);
        nodes.put(LEVEL2_NODE1.uuid(), level2Node1);
        nodes.put(LEVEL2_NODE2.uuid(), level2Node2);
        replacedertEquals(nodes.size(), nodeCaptor.getAllValues().size());
        nodes.entrySet().forEach(entry -> {
            Optional<Node<View<? extends BPMNViewDefinition>, ?>> processed = nodeCaptor.getAllValues().stream().filter(captured -> entry.getKey().equals(captured.getUUID())).findFirst();
            replacedertTrue("Node: " + entry.getKey() + " was not present in result", processed.isPresent());
            replacedertEquals(entry.getValue(), processed.get().getContent().getDefinition());
        });
    }

    static clreplaced MyProcessConverter extends ProcessConverterDelegate {

        public MyProcessConverter(ConverterFactory converterFactory) {
            super(converterFactory);
        }
    }
}

17 View Complete Implementation : CareBehaviorTemplateListControllerTest.java
Copyright Apache License 2.0
Author : arcus-smart-home
public clreplaced CareBehaviorTemplateListControllerTest extends MockClientTestCase {

    CareBehaviorTemplateListController controller;

    SettableModelSource<SubsystemModel> source;

    CareBehaviorTemplateListController.Callback callback;

    @Captor
    ArgumentCaptor<List<BehaviorTemplate>> satisfiableArgCap;

    @Captor
    ArgumentCaptor<List<BehaviorTemplate>> nonSatisfiableArgCap;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        source = new SettableModelSource<>();
        controller = new CareBehaviorTemplateListController(source);
        callback = Mockito.mock(CareBehaviorTemplateListController.Callback.clreplaced);
        controller.setCallback(callback);
        expectRequestOfType(CareSubsystem.ListBehaviorsRequest.NAME).andRespondFromPath("subsystems/care/listBehaviorsResponse.json");
        expectRequestOfType(CareSubsystem.ListBehaviorTemplatesRequest.NAME).andRespondFromPath("subsystems/care/listBehaviorTemplatesResponse.json");
    }

    @Test
    public void showTemplates() throws Exception {
        source.set((SubsystemModel) Fixtures.loadModel("subsystems/care/subsystemAlarmReadyON.json"));
        controller.listBehaviorTemplates();
        Mockito.verify(callback, Mockito.times(1)).showTemplates(satisfiableArgCap.capture(), nonSatisfiableArgCap.capture());
        List<BehaviorTemplate> satisfiable = satisfiableArgCap.getValue();
        List<BehaviorTemplate> nonSatisfiable = nonSatisfiableArgCap.getValue();
        replacedertNotNull(satisfiable);
        replacedertNotNull(nonSatisfiable);
        replacedertFalse(satisfiable.isEmpty());
        replacedertTrue(nonSatisfiable.isEmpty());
        Mockito.verifyNoMoreInteractions(callback);
    }
}

17 View Complete Implementation : GuidedDecisionTablePresenterAttributesAndMetadataTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(GwtMockitoTestRunner.clreplaced)
public clreplaced GuidedDecisionTablePresenterAttributesAndMetadataTest extends BaseGuidedDecisionTablePresenterTest {

    @Captor
    private ArgumentCaptor<Set<String>> reservedAttributesCaptor;

    @Captor
    private ArgumentCaptor<Map<String, String>> callbackValueCaptor;

    @Before
    public void setup() {
        super.setup();
        dtPresenter.onAppendRow();
        dtPresenter.onAppendRow();
        dtPresenter.onAppendRow();
    }

    @Test
    public void isMetaDataUnique() {
        final MetadataCol52 metadata = new MetadataCol52();
        metadata.setMetadata("metadata");
        dtPresenter.getModel().getMetadataCols().add(metadata);
        replacedertFalse(dtPresenter.isMetaDataUnique("metadata"));
        replacedertTrue(dtPresenter.isMetaDataUnique("cheese"));
    }

    @Test
    public void appendAttributeColumn() throws VetoException {
        reset(modellerPresenter);
        final AttributeCol52 column = new AttributeCol52();
        column.setAttribute(Attribute.AUTO_FOCUS.getAttributeName());
        dtPresenter.appendColumn(column);
        verify(synchronizer, times(1)).appendColumn(eq(column));
        verify(refreshAttributesPanelEvent, times(1)).fire(any(RefreshAttributesPanelEvent.clreplaced));
        verify(modellerPresenter, times(1)).updateLinks();
    }

    @Test
    public void appendMetadataColumn() throws VetoException {
        reset(modellerPresenter);
        final MetadataCol52 column = new MetadataCol52();
        column.setMetadata("metadata");
        dtPresenter.appendColumn(column);
        verify(synchronizer, times(1)).appendColumn(eq(column));
        verify(refreshMetaDataPanelEvent, times(1)).fire(any(RefreshMetaDataPanelEvent.clreplaced));
        verify(modellerPresenter, times(1)).updateLinks();
    }

    @Test
    public void deleteAttributeColumn() throws VetoException {
        final AttributeCol52 column = new AttributeCol52();
        column.setAttribute(Attribute.AUTO_FOCUS.getAttributeName());
        dtPresenter.appendColumn(column);
        reset(modellerPresenter);
        dtPresenter.deleteColumn(column);
        verify(synchronizer, times(1)).deleteColumn(eq(column));
        verify(modellerPresenter, times(1)).updateLinks();
    }

    @Test
    public void deleteMetadataColumn() throws VetoException {
        final MetadataCol52 column = new MetadataCol52();
        column.setMetadata("metadata");
        dtPresenter.appendColumn(column);
        reset(modellerPresenter);
        dtPresenter.deleteColumn(column);
        verify(synchronizer, times(1)).deleteColumn(eq(column));
        verify(modellerPresenter, times(1)).updateLinks();
    }

    @Test
    public void updateAttributeColumn() throws VetoException {
        final AttributeCol52 column = new AttributeCol52();
        column.setAttribute(Attribute.AUTO_FOCUS.getAttributeName());
        dtPresenter.appendColumn(column);
        reset(modellerPresenter);
        final AttributeCol52 update = new AttributeCol52();
        update.setAttribute(Attribute.ENABLED.getAttributeName());
        dtPresenter.updateColumn(column, update);
        verify(synchronizer, times(1)).updateColumn(eq(column), eq(update));
        verify(modellerPresenter, times(1)).updateLinks();
    }

    @Test
    public void updateMetadataColumn() throws VetoException {
        final MetadataCol52 column = new MetadataCol52();
        column.setMetadata("metadata");
        dtPresenter.appendColumn(column);
        reset(modellerPresenter);
        final MetadataCol52 update = new MetadataCol52();
        column.setMetadata("update");
        dtPresenter.updateColumn(column, update);
        verify(synchronizer, times(1)).updateColumn(eq(column), eq(update));
        verify(modellerPresenter, times(1)).updateLinks();
    }
}

17 View Complete Implementation : CaptorAnnotationUnhappyPathTest.java
Copyright GNU General Public License v2.0
Author : SpoonLabs
@SuppressWarnings("unchecked")
public clreplaced CaptorAnnotationUnhappyPathTest extends TestBase {

    @Captor
    List notACaptorField;

    @Before
    @Override
    public void init() {
    // we need to get rid of parent implementation this time
    }

    @Test
    public void shouldFailIfCaptorHasWrongType() throws Exception {
        try {
            // when
            MockitoAnnotations.initMocks(this);
            fail();
        } catch (MockitoException e) {
            // then
            replacedertContains("notACaptorField", e.getMessage());
            replacedertContains("wrong type", e.getMessage());
        }
    }
}

17 View Complete Implementation : CaptorAnnotationAutoboxingTest.java
Copyright GNU General Public License v2.0
Author : SpoonLabs
// see issue 188
public clreplaced CaptorAnnotationAutoboxingTest extends TestBase {

    interface Fun {

        void doFun(double prmitive);

        void moreFun(int howMuch);
    }

    @Mock
    Fun fun;

    @Captor
    ArgumentCaptor<Double> captor;

    @Test
    public void shouldAutoboxSafely() {
        // given
        fun.doFun(1.0);
        // then
        verify(fun).doFun(captor.capture());
        replacedertEquals((Double) 1.0, captor.getValue());
    }

    @Captor
    ArgumentCaptor<Integer> intCaptor;

    @Test
    public void shouldAutoboxAllPrimitives() {
        verify(fun, never()).moreFun(intCaptor.capture());
    }
}

17 View Complete Implementation : CaptorAnnotationUnhappyPathTest.java
Copyright GNU General Public License v2.0
Author : SpoonLabs
@SuppressWarnings("unchecked")
public clreplaced CaptorAnnotationUnhappyPathTest extends TestBase {

    @Captor
    List notACaptorField;

    @Before
    @Override
    public void init() {
    // we need to get rid of parent implementation this time
    }

    @Test
    public void shouldFailIfCaptorHasWrongType() throws Exception {
        try {
            // when
            MockitoAnnotations.initMocks(this);
            fail();
        } catch (MockitoException e) {
            // then
            replacedertContains("notACaptorField", e.getMessage());
            replacedertContains("wrong type", e.getMessage());
        }
    }
}

17 View Complete Implementation : JGitFSHooksTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced JGitFSHooksTest {

    private static final String FS_NAME = "dora";

    private static final Integer EXIT_CODE = 0;

    @Captor
    private ArgumentCaptor<FileSystemHookExecutionContext> contextArgumentCaptor;

    @Test
    public void executeFSHooksTest() {
        FileSystemHookExecutionContext ctx = new FileSystemHookExecutionContext(FS_NAME);
        testExecuteFSHooks(ctx, FileSystemHooks.ExternalUpdate);
        ctx.addParam(FileSystemHooksConstants.POST_COMMIT_EXIT_CODE, EXIT_CODE);
        testExecuteFSHooks(ctx, FileSystemHooks.PostCommit);
    }

    private void testExecuteFSHooks(FileSystemHookExecutionContext ctx, FileSystemHooks hookType) {
        AtomicBoolean executedWithLambda = new AtomicBoolean(false);
        FileSystemHooks.FileSystemHook hook = spy(new FileSystemHooks.FileSystemHook() {

            @Override
            public void execute(FileSystemHookExecutionContext context) {
                replacedertEquals(FS_NAME, context.getFsName());
            }
        });
        FileSystemHooks.FileSystemHook lambdaHook = context -> {
            replacedertEquals(FS_NAME, context.getFsName());
            executedWithLambda.set(true);
        };
        JGitFSHooks.executeFSHooks(hook, hookType, ctx);
        JGitFSHooks.executeFSHooks(lambdaHook, hookType, ctx);
        verifyFSHook(hook, hookType);
        replacedertTrue(executedWithLambda.get());
    }

    @Test
    public void executeFSHooksArrayTest() {
        FileSystemHookExecutionContext ctx = new FileSystemHookExecutionContext(FS_NAME);
        testExecuteFSHooksArray(ctx, FileSystemHooks.ExternalUpdate);
        ctx.addParam(FileSystemHooksConstants.POST_COMMIT_EXIT_CODE, EXIT_CODE);
        testExecuteFSHooksArray(ctx, FileSystemHooks.PostCommit);
    }

    private void testExecuteFSHooksArray(FileSystemHookExecutionContext ctx, FileSystemHooks hookType) {
        AtomicBoolean executedWithLambda = new AtomicBoolean(false);
        FileSystemHooks.FileSystemHook hook = spy(new FileSystemHooks.FileSystemHook() {

            @Override
            public void execute(FileSystemHookExecutionContext context) {
                replacedertEquals(FS_NAME, context.getFsName());
            }
        });
        FileSystemHooks.FileSystemHook lambdaHook = context -> {
            replacedertEquals(FS_NAME, context.getFsName());
            executedWithLambda.set(true);
        };
        JGitFSHooks.executeFSHooks(Arrays.asList(hook, lambdaHook), hookType, ctx);
        verifyFSHook(hook, hookType);
        replacedertTrue(executedWithLambda.get());
    }

    private void verifyFSHook(FileSystemHooks.FileSystemHook hook, FileSystemHooks hookType) {
        verify(hook).execute(contextArgumentCaptor.capture());
        FileSystemHookExecutionContext ctx = contextArgumentCaptor.getValue();
        replacedertions.replacedertThat(ctx).isNotNull().hasFieldOrPropertyWithValue("fsName", FS_NAME);
        if (hookType.equals(FileSystemHooks.PostCommit)) {
            replacedertions.replacedertThat(ctx.getParamValue(FileSystemHooksConstants.POST_COMMIT_EXIT_CODE)).isNotNull().isEqualTo(EXIT_CODE);
        }
    }
}

17 View Complete Implementation : ProductionInstallExecutorTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(GwtMockitoTestRunner.clreplaced)
public clreplaced ProductionInstallExecutorTest extends AbstractInstallExecutorTest<ProductionInstallExecutor> {

    @Captor
    private ArgumentCaptor<GAV> gavArgumentCaptor;

    @Captor
    private ArgumentCaptor<Command> okCommand;

    @Captor
    private ArgumentCaptor<Command> overrideCommand;

    @Before
    public void setup() {
        super.setup();
        context = getDefaultContext();
        runner = spy(new ProductionInstallExecutor(buildService, buildResultsEvent, notificationEvent, buildDialog, conflictingRepositoriesPopup));
    }

    @Test
    public void testBuildAndInstallGavAlreadyExistException() {
        when(buildServiceMock.buildAndDeploy(any(Module.clreplaced), eq(DeploymentMode.VALIDATED))).thenAnswer(invocationOnMock -> {
            throw new GAVAlreadyExistsException();
        });
        runner.run(context);
        verify(buildDialog).startBuild();
        verify(buildDialog).showBusyIndicator(CONSTANTS.Building());
        verify(buildDialog).hideBusyIndicator();
        verify(conflictingRepositoriesPopup).setContent(gavArgumentCaptor.capture(), any(), okCommand.capture(), overrideCommand.capture());
        replacedertEquals(context.getModule().getPom().getGav(), gavArgumentCaptor.getValue());
        verify(conflictingRepositoriesPopup).show();
        verify(notificationEvent, never()).fire(any());
        verify(buildResultsEvent, never()).fire(any());
        overrideCommand.getValue().execute();
        verify(buildServiceMock).buildAndDeploy(eq(context.getModule()), eq(DeploymentMode.FORCED));
        verifyNotification(CONSTANTS.BuildAndInstallSuccessful(), NotificationEvent.NotificationType.SUCCESS);
        verify(buildResultsEvent).fire(any());
        verify(buildDialog).stopBuild();
        okCommand.getValue().execute();
        verify(buildDialog, times(2)).stopBuild();
    }
}

17 View Complete Implementation : NewUrlFilterTest.java
Copyright MIT License
Author : robsonbittencourt
public clreplaced NewUrlFilterTest {

    @InjectMocks
    private NewUrlFilter newUrlFilter;

    @Mock
    private UrlRepository urlRepository;

    @Captor
    private ArgumentCaptor<Url> urlCaptor;

    @Before
    public void setUp() {
        initMocks(this);
    }

    @Test
    public void shouldSaveOnDataBaseOnlyNewUrls() {
        List<Url> urls = new ArrayList<>();
        urls.add(UrlFixture.get().complete().identifier("5566").build());
        urls.add(UrlFixture.get().complete().identifier("5678").build());
        urls.add(UrlFixture.get().complete().identifier("7788").build());
        List<Url> databaseUrls = new ArrayList<>();
        databaseUrls.add(UrlFixture.get().complete().identifier("1234").build());
        databaseUrls.add(UrlFixture.get().complete().identifier("5678").build());
        databaseUrls.add(UrlFixture.get().complete().identifier("3344").build());
        when(urlRepository.findAll()).thenReturn(databaseUrls);
        Set<Url> newUrls = newUrlFilter.filter(urls);
        verify(urlRepository, times(2)).save(urlCaptor.capture());
        replacedertEquals("5566", urlCaptor.getAllValues().get(0).getIdentifier());
        replacedertEquals("7788", urlCaptor.getAllValues().get(1).getIdentifier());
        replacedertEquals(2, newUrls.size());
    }
}

17 View Complete Implementation : PrintHelperTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(GwtMockitoTestRunner.clreplaced)
public clreplaced PrintHelperTest {

    private PrintHelper helper;

    @Captor
    private ArgumentCaptor<Command> commandArgumentCaptor;

    @Captor
    private ArgumentCaptor<Element> elementArgumentCaptor;

    @Before
    public void setup() {
        helper = spy(new PrintHelper());
    }

    @Test
    public void testPrint() {
        final HTMLElement element = mock(HTMLElement.clreplaced);
        final HTMLDoreplacedent printDoreplacedent = mock(HTMLDoreplacedent.clreplaced);
        final Window globalWindow = mock(Window.clreplaced);
        final Window printWindow = mock(Window.clreplaced);
        doReturn(globalWindow).when(helper).getGlobalWindow();
        doReturn(printDoreplacedent).when(helper).getWindowDoreplacedent(printWindow);
        doNothing().when(helper).writeElementIntoDoreplacedent(any(), any());
        doNothing().when(helper).changeMediaAttributesToAll(any());
        doNothing().when(helper).copyStylesFromWindow(any(), any());
        doNothing().when(helper).setupPrintCommandOnPageLoad(any(), any());
        when(globalWindow.open("", "_blank")).thenReturn(printWindow);
        helper.print(element);
        verify(helper).writeElementIntoDoreplacedent(element, printDoreplacedent);
        verify(helper).changeMediaAttributesToAll(printDoreplacedent);
        verify(helper).copyStylesFromWindow(printDoreplacedent, globalWindow);
        verify(helper).setupPrintCommandOnPageLoad(printDoreplacedent, printWindow);
    }

    @Test
    public void testWriteElementIntoDoreplacedent() {
        final HTMLElement element = mock(HTMLElement.clreplaced);
        final HTMLDoreplacedent doreplacedent = mock(HTMLDoreplacedent.clreplaced);
        final HTMLBodyElement body = mock(HTMLBodyElement.clreplaced);
        final String elementHTML = "<html />";
        final DOMTokenList clreplacedList = mock(DOMTokenList.clreplaced);
        element.innerHTML = elementHTML;
        doreplacedent.body = body;
        body.clreplacedList = clreplacedList;
        helper.writeElementIntoDoreplacedent(element, doreplacedent);
        verify(doreplacedent).open();
        verify(doreplacedent).write(elementHTML);
        verify(doreplacedent).close();
        verify(clreplacedList).add(PREVIEW_SCREEN_CSS_CLreplaced);
    }

    @Test
    public void testChangeMediaAttributesToAll() {
        final HTMLDoreplacedent doreplacedent = mock(HTMLDoreplacedent.clreplaced);
        final Element element = mock(Element.clreplaced);
        final NodeList<Element> links = spy(new NodeList<>());
        final String media = "media";
        links.length = 1;
        doReturn(element).when(links).item(0);
        doReturn(element).when(helper).asElement(element);
        when(doreplacedent.querySelectorAll("link")).thenReturn(links);
        when(element.getAttribute(media)).thenReturn("print");
        helper.changeMediaAttributesToAll(doreplacedent);
        verify(element).setAttribute(media, "all");
    }

    @Test
    public void testCopyStylesFromWindow() {
        final HTMLDoreplacedent doreplacedent = mock(HTMLDoreplacedent.clreplaced);
        final HTMLDoreplacedent topDoreplacedent = mock(HTMLDoreplacedent.clreplaced);
        final Window window = mock(Window.clreplaced);
        final Window topWindow = mock(Window.clreplaced);
        final Element element = mock(Element.clreplaced);
        final Element head = mock(Element.clreplaced);
        final NodeList<Element> parentStyles = spy(new NodeList<>());
        parentStyles.length = 1;
        window.top = topWindow;
        element.innerHTML = ".page { background: red }";
        doReturn(element).when(parentStyles).item(0);
        doReturn(topDoreplacedent).when(helper).getWindowDoreplacedent(topWindow);
        doReturn(element).when(helper).asElement(element);
        doReturn(head).when(helper).asElement(head);
        doReturn(mock(Element.clreplaced)).when(helper).createElement("style");
        when(doreplacedent.querySelector("head")).thenReturn(head);
        when(topDoreplacedent.querySelectorAll("style")).thenReturn(parentStyles);
        helper.copyStylesFromWindow(doreplacedent, window);
        verify(head).appendChild(elementArgumentCaptor.capture());
        final Element copiedStyle = elementArgumentCaptor.getValue();
        replacedertEquals(".page { background: red }", copiedStyle.innerHTML);
    }

    @Test
    public void testSetupPrintCommandOnPageLoad() {
        final HTMLDoreplacedent doreplacedent = mock(HTMLDoreplacedent.clreplaced);
        final Window window = mock(Window.clreplaced);
        doreplacedent.body = mock(HTMLBodyElement.clreplaced);
        doNothing().when(helper).setTimeout(any(), anyInt());
        helper.setupPrintCommandOnPageLoad(doreplacedent, window);
        doreplacedent.body.onload.onInvoke(mock(Event.clreplaced));
        verify(helper).setTimeout(commandArgumentCaptor.capture(), eq(10));
        commandArgumentCaptor.getValue().execute();
        verify(window).focus();
        verify(window).print();
        verify(window).close();
    }
}

16 View Complete Implementation : GitIgnoreCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced GitIgnoreCreatorTest {

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Map<String, Object>> mapCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new GitIgnoreCreator(fileProcessor);
    }

    @Test
    public void replacederreplacedCreateFile() {
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        creator.create(request);
        verify(this.fileProcessor, times(1)).touch(Paths.get("./.gitignore"));
    }

    @Test
    public void replacedertTemplateIsParsed() {
        ProjectCreation request = ProjectCreation.builder().rootDir(".").type(ApplicationType.NODE).build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).processTemplate(eq(GitIgnoreCreator.GIT_IGNORE_TEMPLATE_PATH), mapCaptor.capture());
        Map<String, Object> args = mapCaptor.getValue();
        replacedertTrue((boolean) args.get("IS_NODE"));
        replacedertFalse((boolean) args.get("IS_JAVA_BASED"));
        replacedertFalse((boolean) args.get("IS_REACT"));
    }
}

16 View Complete Implementation : JavaIntegrationTestSrcCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced JavaIntegrationTestSrcCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<File> fileCaptor;

    private FileCreator<ProjectCreation> srcFileCreator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.srcFileCreator = new JavaIntegrationTestSrcCreator(fileProcessor);
    }

    @Test
    public void replacedertOrderIsBiggerThanSrcCreator() {
        replacedertTrue(srcFileCreator.order() > FileCreationOrder.SRC_FOLDER.order());
    }

    @Test
    public void replacedertFolderIsCreated() throws IOException {
        ProjectCreation request = ProjectCreation.builder().rootDir(folder.getRoot().getAbsolutePath()).build();
        srcFileCreator.create(request);
        verify(fileProcessor, times(2)).createDirectories(this.fileCaptor.capture());
        replacedertTrue(this.fileCaptor.getAllValues().stream().map(File::toPath).allMatch(this::srcIsCreatedUnderRootFolder));
    }

    private boolean srcIsCreatedUnderRootFolder(Path input) {
        return input.equals(folder.getRoot().toPath().resolve("src/acceptanceTest/java")) || input.equals(folder.getRoot().toPath().resolve("src/acceptanceTest/resources"));
    }
}

16 View Complete Implementation : ReceiverTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(GwtMockitoTestRunner.clreplaced)
public clreplaced ReceiverTest {

    @Mock
    private Worker worker;

    @Captor
    private ArgumentCaptor<MessageHandler> messageHandlerArgumentCaptor;

    @Captor
    private ArgumentCaptor<Set> setArgumentCaptor;

    @Mock
    private replacedysisReporter reporter;

    private Receiver receiver;

    private Object returnObject;

    @Before
    public void setUp() {
        receiver = new Receiver(reporter) {

            @Override
            public Object fromJSON(final String json) {
                return returnObject;
            }
        };
        receiver.setUp(worker);
        verify(worker).setOnMessage(messageHandlerArgumentCaptor.capture());
    }

    @Test
    public void status() {
        returnObject = new Status();
        messageHandlerArgumentCaptor.getValue().onMessage(mock(MessageEvent.clreplaced));
        verify(reporter).sendStatus((Status) returnObject);
    }

    @Test
    public void issues() {
        returnObject = new Issues("id", new HashSet<>());
        messageHandlerArgumentCaptor.getValue().onMessage(mock(MessageEvent.clreplaced));
        verify(reporter).sendReport(anySet());
    }

    @Test
    public void webWorkerException() {
        returnObject = new WebWorkerException("error");
        messageHandlerArgumentCaptor.getValue().onMessage(mock(MessageEvent.clreplaced));
        verify(reporter, never()).sendStatus(any());
        verify(reporter).sendReport(setArgumentCaptor.capture());
        verify(worker).terminate();
        final Set<Issue> issues = setArgumentCaptor.getValue();
        replacedertEquals(1, issues.size());
        replacedertTrue(issues.iterator().next() instanceof IllegalVerifierStateIssue);
    }
}

16 View Complete Implementation : PackageJsonCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced PackageJsonCreatorTest {

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    @Captor
    private ArgumentCaptor<Map<String, Object>> mapCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new PackageJsonCreator(fileProcessor);
    }

    @Test
    public void replacedertPackageJsonIsCreated() {
        ProjectCreation request = ProjectCreation.builder().group("hopper").name("test-app").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path packageJsonPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./package.json"), packageJsonPath);
    }

    @Test
    public void replacedertTemplateIsParsed() {
        ProjectCreation request = ProjectCreation.builder().group("hopper").name("test-app").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).processTemplate(eq(PackageJsonCreator.PACKAGE_JSON_TPL_PATH), mapCaptor.capture());
        Map<String, Object> args = mapCaptor.getValue();
        replacedertEquals("hopper-test-app", args.get("APP_NAME"));
        replacedertEquals("hopper", args.get("PROJECT_NAME"));
        replacedertEquals("test-app", args.get("REPO_NAME"));
    }
}

16 View Complete Implementation : PackageInfoCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced PackageInfoCreatorTest {

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new PackageInfoCreator(fileProcessor);
    }

    @Test
    public void replacedertOrder() {
        replacedertTrue(creator.order() == FileCreationOrder.PACKAGE_INFO_TEST.order());
        replacedertTrue(creator.order() > FileCreationOrder.JAVA_PACKAGES.order());
    }

    @Test
    public void replacedertPackageInfoIsCreated() {
        ProjectCreation request = ProjectCreation.builder().group("hopper").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path path = pathCaptor.getValue();
        replacedertEquals(Paths.get("./src/test/java/com/hopper/package-info.java"), path);
    }
}

16 View Complete Implementation : PackageJsonCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced PackageJsonCreatorTest {

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    @Captor
    private ArgumentCaptor<Map<String, Object>> mapCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new PackageJsonCreator(fileProcessor);
    }

    @Test
    public void replacedertPackageJsonIsCreated() {
        ProjectCreation request = ProjectCreation.builder().group("hopper").name("test-app").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path packageJsonPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./package.json"), packageJsonPath);
    }

    @Test
    public void replacedertTemplateIsParsed() {
        ProjectCreation request = ProjectCreation.builder().group("hopper").name("test-app").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).processTemplate(eq(PackageJsonCreator.PACKAGE_JSON_TPL_PATH), mapCaptor.capture());
        Map<String, Object> args = mapCaptor.getValue();
        replacedertEquals("hopper-test-app", args.get("APP_NAME"));
        replacedertEquals("hopper", args.get("PROJECT_NAME"));
        replacedertEquals("test-app", args.get("REPO_NAME"));
    }
}

16 View Complete Implementation : JavaMainSrcCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced JavaMainSrcCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<File> fileCaptor;

    private FileCreator<ProjectCreation> srcFileCreator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.srcFileCreator = new JavaMainSrcCreator(fileProcessor);
    }

    @Test
    public void replacedertOrderIsBiggerThanSrcCreator() {
        replacedertTrue(srcFileCreator.order() > FileCreationOrder.SRC_FOLDER.order());
    }

    @Test
    public void replacedertFolderIsCreated() throws IOException {
        ProjectCreation request = ProjectCreation.builder().rootDir(folder.getRoot().getAbsolutePath()).build();
        srcFileCreator.create(request);
        verify(fileProcessor, times(2)).createDirectories(this.fileCaptor.capture());
        replacedertTrue(this.fileCaptor.getAllValues().stream().map(File::toPath).allMatch(this::srcIsCreatedUnderRootFolder));
    }

    private boolean srcIsCreatedUnderRootFolder(Path input) {
        return input.equals(folder.getRoot().toPath().resolve("src/main/java")) || input.equals(folder.getRoot().toPath().resolve("src/main/resources"));
    }
}

16 View Complete Implementation : CustomDataTypeTextBoxTest.java
Copyright Apache License 2.0
Author : kiegroup
public clreplaced CustomDataTypeTextBoxTest {

    private static final String ERROR_REMOVED = "some error reg exp";

    private static final String ERROR_TYPED = "some error reg exp2";

    @Captor
    private ArgumentCaptor<BlurHandler> blurCaptor;

    @Captor
    private ArgumentCaptor<KeyPressHandler> keyPressCaptor;

    @Mock
    private BlurEvent blurEvent;

    @Mock
    private KeyPressEvent keyPressEvent;

    private CustomDataTypeTextBox textBox;

    @Before
    public void init() {
        GwtMockito.initMocks(this);
        textBox = GWT.create(CustomDataTypeTextBox.clreplaced);
        doCallRealMethod().when(textBox).setRegExp(anyString(), anyString(), anyString());
        doCallRealMethod().when(textBox).isValidValue(anyString(), anyBoolean());
        doCallRealMethod().when(textBox).setText(anyString());
        doCallRealMethod().when(textBox).makeValidValue(anyString());
        doCallRealMethod().when(textBox).getInvalidCharsInName(anyString());
        doCallRealMethod().when(textBox).isValidChar(anyChar());
        doCallRealMethod().when(textBox).setup();
        doCallRealMethod().when(textBox).addBlurHandler(any(BlurHandler.clreplaced));
        doCallRealMethod().when(textBox).addKeyPressHandler(any(KeyPressHandler.clreplaced));
        textBox.setRegExp(StringUtils.ALPHA_NUM_UNDERSCORE_DOT_REGEXP, ERROR_REMOVED, ERROR_TYPED);
    }

    @Test
    public void testSetup() {
        when(textBox.getKeyCodeFromKeyPressEvent(any(KeyPressEvent.clreplaced))).thenReturn(64);
        when(keyPressEvent.isControlKeyDown()).thenReturn(false);
        when(keyPressEvent.isShiftKeyDown()).thenReturn(true);
        when(keyPressEvent.getCharCode()).thenReturn('@');
        when(textBox.getCursorPos()).thenReturn(4);
        when(textBox.getSelectionLength()).thenReturn(0);
        when(textBox.getValue()).thenReturn("ab12");
        when(textBox.getText()).thenReturn("ab12@");
        textBox.setup();
        verify(textBox, times(1)).addBlurHandler(blurCaptor.capture());
        verify(textBox, times(1)).addKeyPressHandler(keyPressCaptor.capture());
        BlurHandler blurHandler = blurCaptor.getValue();
        blurHandler.onBlur(blurEvent);
        verify(textBox, times(1)).isValidValue("ab12@", true);
        verify(textBox, times(1)).makeValidValue("ab12@");
        verify(textBox, times(1)).setValue("ab12");
        KeyPressHandler keyPressHandler = keyPressCaptor.getValue();
        keyPressHandler.onKeyPress(keyPressEvent);
        verify(keyPressEvent, times(1)).preventDefault();
        verify(textBox, times(1)).isValidValue("ab12@", false);
        verify(textBox, times(1)).fireValidationError(ERROR_REMOVED + ": @");
        verify(textBox, times(1)).fireValidationError(ERROR_TYPED + ": @");
    }

    @Test
    public void testMakeValid() {
        String makeValidResult;
        makeValidResult = textBox.makeValidValue(null);
        replacedertEquals("", makeValidResult);
        makeValidResult = textBox.makeValidValue("");
        replacedertEquals("", makeValidResult);
        makeValidResult = textBox.makeValidValue("c");
        replacedertEquals("c", makeValidResult);
        makeValidResult = textBox.makeValidValue("a#b$2%1");
        replacedertEquals("ab21", makeValidResult);
        makeValidResult = textBox.makeValidValue("<a#b$2%1.3-4_5>");
        replacedertEquals("ab21.34_5", makeValidResult);
    }

    @Test
    public void testIsValidValue() {
        String isValidResult;
        isValidResult = textBox.isValidValue("a", true);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("a", false);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("_", true);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("_", false);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("aBc", false);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("CdE", false);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("-", true);
        replacedertEquals(ERROR_REMOVED + ": -", isValidResult);
        isValidResult = textBox.isValidValue("a-b", true);
        replacedertEquals(ERROR_REMOVED + ": -", isValidResult);
        isValidResult = textBox.isValidValue("a#$%1", false);
        replacedertEquals(ERROR_TYPED + ": #$%", isValidResult);
        isValidResult = textBox.isValidValue("Cd.E", false);
        replacedertEquals(null, isValidResult);
        isValidResult = textBox.isValidValue("<a#$%1>", false);
        replacedertEquals(ERROR_TYPED + ": <#$%>", isValidResult);
    }

    @Test
    public void testKeyEnter() {
        when(textBox.getKeyCodeFromKeyPressEvent(any(KeyPressEvent.clreplaced))).thenReturn(KeyCodes.KEY_ENTER);
        when(keyPressEvent.isControlKeyDown()).thenReturn(false);
        when(keyPressEvent.isShiftKeyDown()).thenReturn(false);
        when(keyPressEvent.getCharCode()).thenReturn((char) 13);
        when(textBox.getCursorPos()).thenReturn(4);
        when(textBox.getSelectionLength()).thenReturn(0);
        when(textBox.getValue()).thenReturn("ab12");
        when(textBox.getText()).thenReturn("ab12" + (char) 13);
        textBox.setup();
        verify(textBox, times(1)).addBlurHandler(blurCaptor.capture());
        verify(textBox, times(1)).addKeyPressHandler(keyPressCaptor.capture());
        BlurHandler blurHandler = blurCaptor.getValue();
        blurHandler.onBlur(blurEvent);
        verify(textBox, times(1)).isValidValue("ab12" + (char) 13, true);
        verify(textBox, times(1)).makeValidValue("ab12" + (char) 13);
        verify(textBox, times(1)).setValue("ab12");
        KeyPressHandler keyPressHandler = keyPressCaptor.getValue();
        keyPressHandler.onKeyPress(keyPressEvent);
    }
}

16 View Complete Implementation : AttributeIndexBuilderTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced AttributeIndexBuilderTest {

    @Mock
    DefaultIndexBuilder builder;

    @Captor
    ArgumentCaptor<SharedPart> captor;

    @Test(expected = IllegalStateException.clreplaced)
    public void unSupportedAttribute() {
        new AttributeIndexBuilder(builder).visit(new AttributeDescr("name", "value"));
    }

    @Test()
    public void testIgnored() {
        final AttributeIndexBuilder attributeIndexBuilder = new AttributeIndexBuilder(builder);
        attributeIndexBuilder.visit(new AttributeDescr("no-loop", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("lock-on-active", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("salience", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("auto-focus", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("dialect", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("date-effective", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("date-expires", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("enabled", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("duration", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("timer", "value"));
        attributeIndexBuilder.visit(new AttributeDescr("calendars", "value"));
        verify(builder, never()).addGenerator(any());
    }

    @Test()
    public void testValidValue() {
        new AttributeIndexBuilder(builder).visit(new AttributeDescr("activation-group", "value"));
        verify(builder).addGenerator(captor.capture());
        final SharedPart value = captor.getValue();
        List<KProperty<?>> kProperties = value.toIndexElements();
        replacedertEquals(1, kProperties.size());
        replacedertEquals("shared:activationgroup", kProperties.get(0).getName());
        replacedertEquals("value", kProperties.get(0).getValue());
    }
}

16 View Complete Implementation : SVGShapeProcessorTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced SVGShapeProcessorTest {

    @Mock
    private ProcessingEnvironment processingEnvironment;

    @Mock
    private Messager messager;

    @Mock
    private Filer filer;

    @Mock
    private RoundEnvironment roundEnvironment;

    @Mock
    private Elements elements;

    @Mock
    private TypeElement SVGViewFactoryAnnotation;

    @Mock
    private SVGViewFactory svgViewFactory;

    @Mock
    private DeclaredType svgViewFactoryBuilder;

    @Captor
    private ArgumentCaptor<String> generatedSourceFileNames;

    private Set<? extends TypeElement> elementTypes = new HashSet<>();

    private Set types = new HashSet<>();

    private SVGShapeProcessor processor;

    @Before
    public void setup() throws IOException {
        this.processor = new SVGShapeProcessor();
        this.processor.init(processingEnvironment);
        when(processingEnvironment.getElementUtils()).thenReturn(elements);
        when(processingEnvironment.getMessager()).thenReturn(messager);
        when(processingEnvironment.getFiler()).thenReturn(filer);
        final JavaFileObject jfo = mock(JavaFileObject.clreplaced);
        when(filer.createSourceFile(any(CharSequence.clreplaced))).thenReturn(jfo);
        when(jfo.openWriter()).thenReturn(mock(Writer.clreplaced));
        doThrow(new MirroredTypeException(svgViewFactoryBuilder)).when(svgViewFactory).builder();
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testMultipleSVGViewFactories() throws Exception {
        types.add(makeTypeElement("Factory1"));
        types.add(makeTypeElement("Factory2"));
        when(roundEnvironment.errorRaised()).thenReturn(false);
        when(roundEnvironment.getElementsAnnotatedWith(SVGViewFactoryAnnotation)).thenReturn(types);
        when(elements.getTypeElement(SVGShapeProcessor.ANNOTATION_SVGSHAPE_VIEW_FACTORY)).thenReturn(SVGViewFactoryAnnotation);
        // First round processing gathering requirements
        when(roundEnvironment.processingOver()).thenReturn(false);
        processor.processWithExceptions(elementTypes, roundEnvironment);
        // Last round processing writing generated files
        when(roundEnvironment.processingOver()).thenReturn(true);
        processor.processWithExceptions(elementTypes, roundEnvironment);
        verify(filer, times(2)).createSourceFile(generatedSourceFileNames.capture());
        replacedertContains(this.getClreplaced().getPackage().getName() + ".Factory1Impl");
        replacedertContains(this.getClreplaced().getPackage().getName() + ".Factory2Impl");
    }

    private void replacedertContains(final String fileName) throws FileNotFoundException {
        generatedSourceFileNames.getAllValues().stream().filter(fn -> Objects.equals(fn, fileName)).findFirst().orElseThrow(() -> new FileNotFoundException("Expected generated file '" + fileName + "' not found."));
    }

    private TypeElement makeTypeElement(final String name) {
        final Name typeElementName = mock(Name.clreplaced);
        final Name packageElementName = mock(Name.clreplaced);
        final TypeElement typeElement = mock(TypeElement.clreplaced);
        final PackageElement packageElement = mock(PackageElement.clreplaced);
        when(typeElementName.toString()).thenReturn(name);
        when(packageElementName.toString()).thenReturn(this.getClreplaced().getPackage().getName());
        when(typeElement.getKind()).thenReturn(ElementKind.INTERFACE);
        when(typeElement.getEnclosingElement()).thenReturn(packageElement);
        when(typeElement.getSimpleName()).thenReturn(typeElementName);
        when(typeElement.getAnnotation(SVGViewFactory.clreplaced)).thenReturn(svgViewFactory);
        when(packageElement.getQualifiedName()).thenReturn(packageElementName);
        return typeElement;
    }
}

16 View Complete Implementation : IndexHtmlCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced IndexHtmlCreatorTest {

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    @Captor
    private ArgumentCaptor<Map<String, Object>> mapCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new IndexHtmlCreator(fileProcessor);
    }

    @Test
    public void replacedertIndexHtmlIsCreated() {
        ProjectCreation request = ProjectCreation.builder().name("test-app").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path indexHtmlPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./src/index.html"), indexHtmlPath);
    }

    @Test
    public void replacedertTemplateIsParsed() {
        ProjectCreation request = ProjectCreation.builder().name("test-app").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).processTemplate(eq(IndexHtmlCreator.INDEX_HTML_TPL_PATH), mapCaptor.capture());
        Map<String, Object> args = mapCaptor.getValue();
        replacedertEquals("test-app", args.get("REPO_NAME"));
    }
}

16 View Complete Implementation : BaseDOMElementSingletonColumnTest.java
Copyright Apache License 2.0
Author : kiegroup
public abstract clreplaced BaseDOMElementSingletonColumnTest<F extends BaseSingletonDOMElementFactory, D extends BaseDOMElement & TakesValue<String> & Focusable, W extends Widget & Focusable, C extends BaseGridColumn & HreplacedingletonDOMElementResource, G extends BaseExpressionGrid> {

    private static final String DEFAULT_VALUE = "";

    @Mock
    protected GridColumn.HeaderMetaData headerMetaData;

    @Mock
    protected GridBodyCellRenderContext context;

    @Captor
    protected ArgumentCaptor<Consumer<D>> domElementOnCreationCallbackCaptor;

    @Captor
    protected ArgumentCaptor<Consumer<D>> domElementOnDisplayCallbackCaptor;

    protected GridData model;

    protected F factory;

    protected D domElement;

    protected W widget;

    protected G gridWidget;

    protected C column;

    @Before
    public void setup() {
        this.model = new DMNGridData();
        this.factory = getFactory();
        this.domElement = getDomElement();
        this.widget = getWidget();
        this.gridWidget = getGridWidget();
        this.column = getColumn();
        when(domElement.getWidget()).thenReturn(widget);
        when(gridWidget.getModel()).thenReturn(model);
    }

    protected abstract F getFactory();

    protected abstract D getDomElement();

    protected abstract W getWidget();

    protected abstract G getGridWidget();

    protected abstract C getColumn();

    @Test
    @SuppressWarnings("unchecked")
    public void checkEdit() {
        final String value = "value";
        final GridCell<String> cell = new BaseGridCell<>(new BaseGridCellValue<>(value));
        column.edit(cell, context, result -> {
        /*Nothing*/
        });
        replacedertCellEdit(value);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void checkEditNullCell() {
        column.edit(null, context, result -> {
        /*Nothing*/
        });
        replacedertCellEdit(DEFAULT_VALUE);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void checkEditNullCellValue() {
        final GridCell<String> cell = new BaseGridCell<>(null);
        column.edit(cell, context, result -> {
        /*Nothing*/
        });
        replacedertCellEdit(DEFAULT_VALUE);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void checkEditNullCellValueValue() {
        final GridCell<String> cell = new BaseGridCell<>(new BaseGridCellValue<>(null));
        column.edit(cell, context, result -> {
        /*Nothing*/
        });
        replacedertCellEdit(DEFAULT_VALUE);
    }

    @SuppressWarnings("unchecked")
    protected void replacedertCellEdit(final String value) {
        verify(factory).attachDomElement(eq(context), domElementOnCreationCallbackCaptor.capture(), domElementOnDisplayCallbackCaptor.capture());
        final Consumer<D> domElementOnCreationCallback = domElementOnCreationCallbackCaptor.getValue();
        domElementOnCreationCallback.accept(domElement);
        verify(domElement).setValue(eq(value));
        final Consumer<D> domElementOnDisplayCallback = domElementOnDisplayCallbackCaptor.getValue();
        domElementOnDisplayCallback.accept(domElement);
        verify(domElement).setFocus(eq(true));
    }

    @Test
    public void checkFlushFactory() {
        column.flush();
        verify(factory).flush();
    }

    @Test
    public void checkDestroyFactoryResources() {
        column.destroyResources();
        verify(factory).destroyResources();
    }

    @Test
    public void testDestroyHeaderMetadataAdditionalDomElements() {
        final EditableHeaderMetaData editableHeaderMetaData = mock(EditableHeaderMetaData.clreplaced);
        column.getHeaderMetaData().add(editableHeaderMetaData);
        column.destroyResources();
        verify(editableHeaderMetaData).destroyResources();
    }
}

16 View Complete Implementation : TestRunnerReportingPanelTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(GwtMockitoTestRunner.clreplaced)
public clreplaced TestRunnerReportingPanelTest {

    @Captor
    private ArgumentCaptor<PublishBatchMessagesEvent> publishEventCaptor;

    @Mock
    private TestRunnerReportingView view;

    @Mock
    private Failure failure;

    @Mock
    private EventSourceMock event;

    private TestRunnerReportingPanel screen;

    @Before
    public void setUp() {
        screen = new TestRunnerReportingPanel(view, event);
    }

    @Test
    public void testEventGoesThroughCorrectly() {
        when(failure.getDisplayName()).thenReturn("Display name.");
        when(failure.getMessage()).thenReturn("Message");
        final Path path = mock(Path.clreplaced);
        when(failure.getPath()).thenReturn(path);
        screen.onTestRun(createTRMWithFailures());
        screen.onViewAlerts();
        verify(event).fire(publishEventCaptor.capture());
        final PublishBatchMessagesEvent value = publishEventCaptor.getValue();
        replacedertTrue(value.isCleanExisting());
        replacedertEquals(1, value.getMessagesToPublish().size());
        final SystemMessage systemMessage = value.getMessagesToPublish().get(0);
        replacedertEquals("TestResults", systemMessage.getMessageType());
        replacedertEquals(Level.ERROR, systemMessage.getLevel());
        replacedertEquals(path, systemMessage.getPath());
        replacedertEquals("Display name. : Message", systemMessage.getText());
    }

    @Test
    public void onViewAlerts() {
        screen.onViewAlerts();
        verify(event).fire(publishEventCaptor.capture());
        final PublishBatchMessagesEvent value = publishEventCaptor.getValue();
        replacedertTrue(value.isCleanExisting());
        replacedertTrue(value.getMessagesToPublish().isEmpty());
    }

    @Test
    public void onViewAlertsSendMessage() {
        screen.onTestRun(createTRMWithFailures());
        screen.onViewAlerts();
        verify(event).fire(publishEventCaptor.capture());
        final PublishBatchMessagesEvent value = publishEventCaptor.getValue();
        replacedertFalse(value.getMessagesToPublish().isEmpty());
    }

    @Test
    public void onViewAlerts_resetBetweenRuns() {
        screen.onTestRun(createTRMWithFailures());
        screen.onTestRun(createTRMWithoutFailures(2500));
        screen.onViewAlerts();
        verify(event).fire(publishEventCaptor.capture());
        final PublishBatchMessagesEvent value = publishEventCaptor.getValue();
        replacedertTrue(value.getMessagesToPublish().isEmpty());
    }

    @Test
    public void testSetPresenter() {
        verify(view).setPresenter(screen);
    }

    @Test
    public void initFailureDiagram() {
        verify(view).resetDonut();
    }

    @Test
    public void testSuccessfulRun() {
        screen.onTestRun(createTRMWithoutFailures(250));
        verify(view).showSuccess();
        verify(view).setRunStatus(any(), eq("1"), eq("250 milliseconds"));
    }

    @Test
    public void testUnSuccessfulRun() {
        reset(view);
        when(failure.getDisplayName()).thenReturn("Expected true but was false.");
        when(failure.getMessage()).thenReturn("This is a non-null message");
        screen.onTestRun(createTRMWithFailures());
        verify(view).showFailure();
        verify(view).showSuccessFailureDiagram(0, 1);
        verify(view).setRunStatus(any(), eq("1"), eq("2 seconds and 500 milliseconds"));
    }

    @Test
    public void testRunTimeInMinutes() {
        reset(view);
        screen.onTestRun(createTRMWithoutFailures(125000));
        verify(view).showSuccess();
        verify(view).showSuccessFailureDiagram(1, 0);
        verify(view).setRunStatus(any(), eq("1"), eq("2 minutes and 5 seconds"));
    }

    @Test
    public void testMillisecondsFormatting() {
        Softreplacedertions.replacedertSoftly(softly -> {
            softly.replacedertThat(screen.formatMilliseconds("0")).isEqualTo("0");
            softly.replacedertThat(screen.formatMilliseconds("00")).isEqualTo("0");
            softly.replacedertThat(screen.formatMilliseconds("110")).isEqualTo("110");
            softly.replacedertThat(screen.formatMilliseconds("0101")).isEqualTo("101");
            softly.replacedertThat(screen.formatMilliseconds("000110")).isEqualTo("110");
        });
    }

    private TestResultMessage createTRMWithoutFailures(long runtime) {
        return new TestResultMessage("id", 1, runtime, new ArrayList<>());
    }

    private TestResultMessage createTRMWithFailures() {
        return new TestResultMessage("id", 1, 2500, Collections.singletonList(failure));
    }
}

16 View Complete Implementation : ApplicationYamlCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced ApplicationYamlCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> fileCaptor;

    private FileCreator<ProjectCreation> srcFileCreator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.srcFileCreator = new ApplicationYamlCreator(fileProcessor);
    }

    @Test
    public void replacederreplacedRunsAfterResourceFolder() {
        replacedertTrue(this.srcFileCreator.order() > FileCreationOrder.JAVA_MAIN_FOLDER.order());
    }

    @Test
    public void replacedertFileIsCreated() throws IOException {
        ProjectCreation request = ProjectCreation.builder().rootDir(folder.getRoot().getAbsolutePath()).type(ApplicationType.JAVA_SPRING_BOOT).build();
        srcFileCreator.create(request);
        verify(fileProcessor, times(1)).touch(this.fileCaptor.capture());
        Path path = this.fileCaptor.getValue();
        replacedertEquals(Paths.get(folder.getRoot().getAbsolutePath() + ApplicationYamlCreator.APPLICATION_YML_PATH), path);
    }
}

16 View Complete Implementation : ExpressionEditorControlImplTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(LienzoMockitoTestRunner.clreplaced)
public clreplaced ExpressionEditorControlImplTest {

    @Mock
    private DMNSession session;

    @Mock
    private ExpressionEditorView view;

    @Mock
    private DecisionNavigatorPresenter decisionNavigator;

    @Mock
    private DMNGraphUtils dmnGraphUtils;

    @Mock
    private EventSourceMock<CanvasElementUpdatedEvent> canvasElementUpdatedEvent;

    @Mock
    private ExpressionEditorView.Presenter editor;

    @Mock
    private AbstractCanvasHandler canvasHandler;

    @Mock
    private Diagram diagram;

    @Mock
    private Graph<?, Node> graph;

    @Mock
    private Node node;

    @Mock
    private DomainObject domainObject;

    @Mock
    private CanvreplacedelectionEvent event;

    @Captor
    private ArgumentCaptor<CanvasDomainObjectListener> domainObjectListenerCaptor;

    @Captor
    private ArgumentCaptor<CanvasElementUpdatedEvent> canvasElementUpdatedEventCaptor;

    private ExpressionEditorControlImpl control;

    @Before
    public void setup() {
        this.control = spy(new ExpressionEditorControlImpl(view, decisionNavigator, dmnGraphUtils, canvasElementUpdatedEvent));
        doReturn(editor).when(control).makeExpressionEditor(any(ExpressionEditorView.clreplaced), any(DecisionNavigatorPresenter.clreplaced), any(DMNGraphUtils.clreplaced));
        when(session.getCanvasHandler()).thenReturn(canvasHandler);
        when(canvasHandler.getDiagram()).thenReturn(diagram);
        when(diagram.getGraph()).thenReturn(graph);
    }

    @Test
    public void testBind() {
        control.bind(session);
        replacedertNotNull(control.getExpressionEditor());
        verify(editor).bind(session);
        verify(canvasHandler).addDomainObjectListener(any(CanvasDomainObjectListener.clreplaced));
    }

    @Test
    public void testBindDomainObjectListenerWithNodeMatch() {
        final Definition definition = mock(Definition.clreplaced);
        when(graph.nodes()).thenReturn(Collections.singletonList(node));
        when(node.getContent()).thenReturn(definition);
        when(definition.getDefinition()).thenReturn(domainObject);
        when(domainObject.getDomainObjectUUID()).thenReturn("uuid");
        control.bind(session);
        verify(canvasHandler).addDomainObjectListener(domainObjectListenerCaptor.capture());
        final CanvasDomainObjectListener domainObjectListener = domainObjectListenerCaptor.getValue();
        domainObjectListener.update(domainObject);
        verify(canvasElementUpdatedEvent).fire(canvasElementUpdatedEventCaptor.capture());
        final CanvasElementUpdatedEvent canvasElementUpdatedEvent = canvasElementUpdatedEventCaptor.getValue();
        replacedertThat(canvasElementUpdatedEvent.getCanvasHandler()).isEqualTo(canvasHandler);
        replacedertThat(canvasElementUpdatedEvent.getElement()).isEqualTo(node);
    }

    @Test
    public void testBindDomainObjectListenerWithNoNodeMatch() {
        when(graph.nodes()).thenReturn(Collections.emptyList());
        control.bind(session);
        verify(canvasHandler).addDomainObjectListener(domainObjectListenerCaptor.capture());
        final CanvasDomainObjectListener domainObjectListener = domainObjectListenerCaptor.getValue();
        domainObjectListener.update(domainObject);
        verify(canvasElementUpdatedEvent, never()).fire(any(CanvasElementUpdatedEvent.clreplaced));
    }

    @Test
    public void testDoInit() {
        replacedertNull(control.getExpressionEditor());
        control.doInit();
        replacedertNull(control.getExpressionEditor());
    }

    @Test
    public void testDoDestroy() {
        control.bind(session);
        verify(canvasHandler).addDomainObjectListener(domainObjectListenerCaptor.capture());
        control.doDestroy();
        replacedertNull(control.getExpressionEditor());
        final CanvasDomainObjectListener domainObjectListener = domainObjectListenerCaptor.getValue();
        verify(canvasHandler).removeDomainObjectListener(domainObjectListener);
    }

    @Test
    public void testOnCanvasFocusedSelectionEventWhenBound() {
        control.bind(session);
        control.onCanvasFocusedSelectionEvent(event);
        verify(editor).exit();
    }

    @Test
    public void testOnCanvasFocusedSelectionEventWhenNotBound() {
        control.onCanvasFocusedSelectionEvent(event);
        verifyNoMoreInteractions(editor);
    }

    @Test
    public void testOnCanvasElementUpdated() {
        control.bind(session);
        final CanvasElementUpdatedEvent event = new CanvasElementUpdatedEvent(canvasHandler, node);
        control.onCanvasElementUpdated(event);
        verify(editor).handleCanvasElementUpdated(event);
    }
}

16 View Complete Implementation : CloneNodeCommandTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced CloneNodeCommandTest extends AbstractCloneCommandTest {

    protected CloneNodeCommand cloneNodeCommand;

    protected Point2D position;

    @Captor
    protected ArgumentCaptor<Bounds> boundsArgumentCaptor;

    @Before
    public void setUp() {
        super.setUp();
        graphInstance.containerNode.setContent(candidateContent);
        this.position = new Point2D(1, 1);
        this.cloneNodeCommand = new CloneNodeCommand(graphInstance.containerNode, graphInstance.parentNode.getUUID(), position, null, childrenTraverseProcessorManagedInstance);
    }

    @Test
    public void testInitialize() throws Exception {
        cloneNodeCommand.initialize(graphCommandExecutionContext);
        Node<View, Edge> clone = cloneNodeCommand.getClone();
        replacedertEquals(clone, this.clone);
        RegisterNodeCommand registerNodeCommand = (RegisterNodeCommand) cloneNodeCommand.getCommands().stream().filter(command -> command instanceof RegisterNodeCommand).findFirst().get();
        replacedertNotNull(registerNodeCommand);
        replacedertEquals(registerNodeCommand.getCandidate(), clone);
        AddChildNodeCommand addChildCommand = (AddChildNodeCommand) cloneNodeCommand.getCommands().stream().filter(command -> command instanceof AddChildNodeCommand).findFirst().get();
        replacedertNotNull(addChildCommand);
        replacedertEquals(addChildCommand.getCandidate(), clone);
        replacedertEquals(addChildCommand.getParent(graphCommandExecutionContext), graphInstance.parentNode);
        if (addChildCommand.getLocation() != null) {
            replacedertEquals(addChildCommand.getLocation().getX(), position.getX(), 0);
            replacedertEquals(addChildCommand.getLocation().getY(), position.getY(), 0);
        }
    }

    @Test
    public void testExecute() {
        cloneNodeCommand.execute(graphCommandExecutionContext);
        Function<Object, Boolean> cloneNodeInstanceFunction = command -> command instanceof CloneNodeCommand;
        replacedertTrue(checkCloneChildrenElement(cloneNodeInstanceFunction, getCheckChildrenNodeFunction(graphInstance.startNode)));
        replacedertTrue(checkCloneChildrenElement(cloneNodeInstanceFunction, getCheckChildrenNodeFunction(graphInstance.intermNode)));
        replacedertTrue(checkCloneChildrenElement(cloneNodeInstanceFunction, getCheckChildrenNodeFunction(graphInstance.endNode)));
        Function<Object, Boolean> cloneConnectorInstanceFunction = command -> command instanceof CloneConnectorCommand;
        replacedertTrue(checkCloneChildrenElement(cloneConnectorInstanceFunction, getCheckChildrenEdgeFunction(graphInstance.edge1)));
        replacedertTrue(checkCloneChildrenElement(cloneConnectorInstanceFunction, getCheckChildrenEdgeFunction(graphInstance.edge2)));
    }

    private Function<CloneNodeCommand, Boolean> getCheckChildrenNodeFunction(Node node) {
        return command -> Objects.equals(command.getCandidate(), node);
    }

    private Function<CloneConnectorCommand, Boolean> getCheckChildrenEdgeFunction(Edge edge) {
        return command -> Objects.equals(command.getCandidate(), edge);
    }

    private <T> boolean checkCloneChildrenElement(Function<Object, Boolean> commandFilter, Function<T, Boolean> candidateFilter) {
        return cloneNodeCommand.getChildrenCommands().stream().filter(command -> commandFilter.apply(command)).map(command -> (T) command).filter(command -> candidateFilter.apply(command)).findFirst().isPresent();
    }

    @Test
    public void testDelegateRulesContextToChildren() throws Exception {
        replacedertFalse(cloneNodeCommand.delegateRulesContextToChildren());
    }

    @Test
    public void testUndo() throws Exception {
        testInitialize();
        cloneNodeCommand.undo(graphCommandExecutionContext);
        verify(graphIndex, times(1)).removeNode(clone);
    }

    @Test
    public void testCloneNodeContentWithProperties() {
        final View cloneContent = mock(View.clreplaced);
        final DefinitionManager definitionManager = mock(DefinitionManager.clreplaced);
        final CloneManager cloneManager = mock(CloneManager.clreplaced);
        final Object clonedDefinition = mock(Object.clreplaced);
        cloneNodeCommand.setClone(clone);
        when(clone.getContent()).thenReturn(cloneContent);
        when(graphCommandExecutionContext.getDefinitionManager()).thenReturn(definitionManager);
        when(definitionManager.cloneManager()).thenReturn(cloneManager);
        when(cloneManager.clone(candidateContent.getDefinition(), ClonePolicy.ALL)).thenReturn(clonedDefinition);
        cloneNodeCommand.cloneNodeContentWithProperties(graphCommandExecutionContext);
        verify(cloneContent).setBounds(boundsArgumentCaptor.capture());
        verify(cloneContent).setDefinition(clonedDefinition);
        final Bounds clonedBounds = boundsArgumentCaptor.getValue();
        replacedertEquals(candidateBounds, clonedBounds);
        replacedertNotSame(candidateBounds, clonedBounds);
    }
}

16 View Complete Implementation : JavaTestSrcCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced JavaTestSrcCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<File> fileCaptor;

    private FileCreator<ProjectCreation> srcFileCreator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.srcFileCreator = new JavaTestSrcCreator(fileProcessor);
    }

    @Test
    public void replacedertOrderIsBiggerThanSrcCreator() {
        replacedertTrue(srcFileCreator.order() > FileCreationOrder.SRC_FOLDER.order());
    }

    @Test
    public void replacedertFolderIsCreated() throws IOException {
        ProjectCreation request = ProjectCreation.builder().rootDir(folder.getRoot().getAbsolutePath()).build();
        srcFileCreator.create(request);
        verify(fileProcessor, times(2)).createDirectories(this.fileCaptor.capture());
        replacedertTrue(this.fileCaptor.getAllValues().stream().map(File::toPath).allMatch(this::srcIsCreatedUnderRootFolder));
    }

    private boolean srcIsCreatedUnderRootFolder(Path input) {
        return input.equals(folder.getRoot().toPath().resolve("src/test/java")) || input.equals(folder.getRoot().toPath().resolve("src/test/resources"));
    }
}

16 View Complete Implementation : InvocationUIModelMapperTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(MockitoJUnitRunner.clreplaced)
public clreplaced InvocationUIModelMapperTest {

    @Mock
    private GridWidget gridWidget;

    @Mock
    private RowNumberColumn uiRowNumberColumn;

    @Mock
    private InvocationParameterColumn uiNameColumn;

    @Mock
    private ExpressionEditorColumn uiExpressionEditorColumn;

    @Mock
    private Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier;

    @Mock
    private ListSelectorView.Presenter listSelector;

    @Mock
    private ExpressionEditorDefinition literalExpressionEditorDefinition;

    @Mock
    private LiteralExpressionGrid literalExpressionEditor;

    @Captor
    private ArgumentCaptor<GridCellTuple> parentCaptor;

    private LiteralExpression literalExpression = new LiteralExpression();

    private BaseGridData uiModel;

    private Invocation invocation;

    private Supplier<Optional<GridCellValue<?>>> cellValueSupplier;

    private InvocationUIModelMapper mapper;

    @SuppressWarnings("unchecked")
    public void setup(final boolean isOnlyVisualChangeAllowedSupplier) {
        this.uiModel = new BaseGridData();
        this.uiModel.appendRow(new BaseGridRow());
        this.uiModel.appendRow(new BaseGridRow());
        this.uiModel.appendColumn(uiRowNumberColumn);
        this.uiModel.appendColumn(uiNameColumn);
        this.uiModel.appendColumn(uiExpressionEditorColumn);
        when(uiRowNumberColumn.getIndex()).thenReturn(0);
        when(uiNameColumn.getIndex()).thenReturn(1);
        when(uiExpressionEditorColumn.getIndex()).thenReturn(2);
        when(gridWidget.getModel()).thenReturn(uiModel);
        final ExpressionEditorDefinitions expressionEditorDefinitions = new ExpressionEditorDefinitions();
        expressionEditorDefinitions.add(literalExpressionEditorDefinition);
        when(expressionEditorDefinitionsSupplier.get()).thenReturn(expressionEditorDefinitions);
        when(literalExpressionEditorDefinition.getModelClreplaced()).thenReturn(Optional.of(literalExpression));
        when(literalExpressionEditor.getExpression()).thenReturn(() -> Optional.of(literalExpression));
        when(literalExpressionEditorDefinition.getEditor(any(GridCellTuple.clreplaced), any(Optional.clreplaced), any(HasExpression.clreplaced), any(Optional.clreplaced), anyBoolean(), anyInt())).thenReturn(Optional.of(literalExpressionEditor));
        final LiteralExpression invocationExpression = new LiteralExpression();
        invocationExpression.getText().setValue("invocation-expression");
        final LiteralExpression bindingExpression = new LiteralExpression();
        bindingExpression.getText().setValue("binding-expression");
        final Binding binding = new Binding();
        final InformationItem parameter = new InformationItem();
        parameter.setName(new Name("p0"));
        binding.setParameter(parameter);
        binding.setExpression(bindingExpression);
        this.invocation = new Invocation();
        this.invocation.setExpression(invocationExpression);
        this.invocation.getBinding().add(binding);
        this.mapper = new InvocationUIModelMapper(gridWidget, () -> uiModel, () -> Optional.of(invocation), () -> isOnlyVisualChangeAllowedSupplier, expressionEditorDefinitionsSupplier, listSelector, 0);
        this.cellValueSupplier = Optional::empty;
    }

    @Test
    public void testFromDMNModelRowNumber() {
        setup(false);
        mapper.fromDMNModel(0, 0);
        replacedertEquals(1, uiModel.getCell(0, 0).getValue().getValue());
        replacedertEquals(RowSelectionStrategy.INSTANCE, uiModel.getCell(0, 0).getSelectionStrategy());
    }

    @Test
    public void testFromDMNModelBindingParameter() {
        setup(false);
        mapper.fromDMNModel(0, 1);
        replacedertEquals("p0", ((InformationItemCell.HasNameAndDataTypeCell) uiModel.getCell(0, 1).getValue().getValue()).getName().getValue());
    }

    @Test
    public void testFromDMNModelBindingExpression() {
        setup(false);
        replacedertFromDMNModelBindingExpression(false);
    }

    @Test
    public void testFromDMNModelBindingExpressionWhenOnlyVisualChangeAllowed() {
        setup(true);
        replacedertFromDMNModelBindingExpression(true);
    }

    private void replacedertFromDMNModelBindingExpression(final boolean isOnlyVisualChangeAllowed) {
        mapper.fromDMNModel(0, 2);
        replacedertNotNull(uiModel.getCell(0, 2));
        replacedertTrue(uiModel.getCell(0, 2).getValue() instanceof ExpressionCellValue);
        final ExpressionCellValue dcv = (ExpressionCellValue) uiModel.getCell(0, 2).getValue();
        replacedertEquals(literalExpressionEditor, dcv.getValue().get());
        verify(literalExpressionEditorDefinition).getEditor(parentCaptor.capture(), eq(Optional.empty()), eq(invocation.getBinding().get(0)), eq(Optional.of(invocation.getBinding().get(0).getParameter())), eq(isOnlyVisualChangeAllowed), eq(1));
        final GridCellTuple parent = parentCaptor.getValue();
        replacedertEquals(0, parent.getRowIndex());
        replacedertEquals(2, parent.getColumnIndex());
        replacedertEquals(gridWidget, parent.getGridWidget());
    }

    @Test
    public void testToDMNModelBindingParameter() {
        setup(false);
        cellValueSupplier = () -> Optional.of(new BaseGridCellValue<>("updated"));
        mapper.toDMNModel(0, 1, cellValueSupplier);
        replacedertEquals("updated", invocation.getBinding().get(0).getParameter().getName().getValue());
    }

    @Test
    public void testToDMNModelBindingExpression() {
        setup(false);
        cellValueSupplier = () -> Optional.of(new ExpressionCellValue(Optional.of(literalExpressionEditor)));
        mapper.toDMNModel(0, 2, cellValueSupplier);
        replacedertEquals(literalExpression, invocation.getBinding().get(0).getExpression());
    }
}

16 View Complete Implementation : ConfJsCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced ConfJsCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new ConfJsCreator(fileProcessor);
    }

    @Test
    public void replacedertOrder() {
        replacedertTrue(creator.order() == FileCreationOrder.CONF_JS.order());
        replacedertTrue(creator.order() > FileCreationOrder.INTEGRATIONTEST_FOLDER.order());
    }

    @Test
    public void replacedertConfJsIsCreated() {
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path confJsPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./acceptanceTest/conf.js"), confJsPath);
    }

    @Test
    public void replacederreplacedCopiesContentToFile() throws IOException {
        File f = folder.newFile("conf.js");
        when(this.fileProcessor.loadResourceFromClreplacedPath(anyString())).thenReturn(new FileInputStream(f));
        when(this.fileProcessor.touch(any())).thenReturn(f);
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        creator.create(request);
        verify(this.fileProcessor, times(1)).copy(any(), eq(f));
    }
}

16 View Complete Implementation : JavaPackageCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced JavaPackageCreatorTest {

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<File> fileCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new JavaPackageCreator(fileProcessor);
    }

    @Test
    public void replacedertOrder() {
        replacedertTrue(creator.order() == FileCreationOrder.JAVA_PACKAGES.order());
        replacedertTrue(creator.order() > FileCreationOrder.SRC_FOLDER.order());
    }

    @Test
    public void replacedertPackagePathIsCreated() {
        ProjectCreation request = ProjectCreation.builder().group("hopper").rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(2)).createDirectories(fileCaptor.capture());
        List<Path> collectedPaths = fileCaptor.getAllValues().stream().map(File::toPath).collect(Collectors.toList());
        replacedertEquals(paths(), collectedPaths);
    }

    private List<Path> paths() {
        return Lists.newArrayList(Paths.get("./src/main/java/com/hopper"), Paths.get("./src/test/java/com/hopper"));
    }
}

16 View Complete Implementation : IndexSpecJsCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced IndexSpecJsCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new IndexSpecJsCreator(fileProcessor);
    }

    @Test
    public void replacedertOrder() {
        replacedertTrue(creator.order() == FileCreationOrder.INDEX_SPEC_JS.order());
        replacedertTrue(creator.order() > FileCreationOrder.TEST_FOLDER.order());
    }

    @Test
    public void replacedertIndexSpecJsIsCreated() {
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path indexJsPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./test/index_spec.js"), indexJsPath);
    }

    @Test
    public void replacederreplacedCopiesContentToFile() throws IOException {
        File f = folder.newFile("index_spec.js");
        when(this.fileProcessor.loadResourceFromClreplacedPath(anyString())).thenReturn(new FileInputStream(f));
        when(this.fileProcessor.touch(any())).thenReturn(f);
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        creator.create(request);
        verify(this.fileProcessor, times(1)).copy(any(), eq(f));
    }
}

16 View Complete Implementation : BPMNShapeViewHandlersTest.java
Copyright Apache License 2.0
Author : kiegroup
@RunWith(LienzoMockitoTestRunner.clreplaced)
public clreplaced BPMNShapeViewHandlersTest {

    private UserTask task;

    private FontHandler<BPMNViewDefinition, ShapeView> fontHandler;

    @Mock
    private WiresShapeViewExt text;

    @Captor
    private ArgumentCaptor<TextWrapperStrategy> wrapper;

    @Captor
    private ArgumentCaptor<Size> sizeConstraints;

    @Before
    public void setUp() {
        task = new UserTask();
        task.getFontSet().getFontBorderSize().setValue(0.0);
        fontHandler = new BPMNShapeViewHandlers.FontHandlerBuilder<>().build();
    }

    @Test
    public void testFontHandler() {
        fontHandler.handle(task, text);
        verify(text).setTextWrapper(wrapper.capture());
        replacedertEquals(wrapper.getValue(), TextWrapperStrategy.TRUNCATE_WITH_LINE_BREAK);
        verify(text).setreplacedleStrokeWidth(0);
        verify(text).setreplacedleStrokeAlpha(0);
        verify(text).setreplacedlePosition(VerticalAlignment.MIDDLE, HorizontalAlignment.CENTER, ReferencePosition.INSIDE, Orientation.HORIZONTAL);
        verify(text, never()).setMargins(anyMap());
        verify(text).setTextSizeConstraints(sizeConstraints.capture());
        final Size size = sizeConstraints.getValue();
        replacedertEquals(size.getHeight(), 100, 0d);
        replacedertEquals(size.getWidth(), 100, 0d);
        replacedertEquals(size.getType(), Size.SizeType.PERCENTAGE);
    }
}

16 View Complete Implementation : BoundaryEventPropertyWriterTest.java
Copyright Apache License 2.0
Author : kiegroup
public clreplaced BoundaryEventPropertyWriterTest extends AbstractBasePropertyWriterTest<BoundaryEventPropertyWriter, BoundaryEvent> {

    @Mock
    private FeatureMap featureMap;

    @Captor
    private ArgumentCaptor<FeatureMap.Entry> entryCaptor;

    @Override
    protected BoundaryEventPropertyWriter newPropertyWriter(BoundaryEvent baseElement, VariableScope variableScope) {
        return new BoundaryEventPropertyWriter(baseElement, variableScope);
    }

    @Override
    protected BoundaryEvent mockElement() {
        BoundaryEvent eventMock = mock(BoundaryEvent.clreplaced);
        when(eventMock.getAnyAttribute()).thenReturn(featureMap);
        return eventMock;
    }

    @Test
    public void testSetCancelActivityTrue() {
        testSetCancelActivity(true);
    }

    @Test
    public void testSetCancelActivityFalse() {
        testSetCancelActivity(false);
    }

    private void testSetCancelActivity(boolean value) {
        propertyWriter.setCancelActivity(value);
        verify(featureMap).add(entryCaptor.capture());
        replacedertEquals(String.format("drools:boundaryca=%s", value), entryCaptor.getValue().toString());
        verify(element).setCancelActivity(value);
    }

    @Test
    public void testSetParentActivity() {
        ActivityPropertyWriter parentActivityWriter = mock(ActivityPropertyWriter.clreplaced);
        Activity activity = mock(Activity.clreplaced);
        when(parentActivityWriter.getFlowElement()).thenReturn(activity);
        propertyWriter.setParentActivity(parentActivityWriter);
        verify(element).setAttachedToRef(activity);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testAddEventDefinition() {
        List<EventDefinition> eventDefinitions = mock(List.clreplaced);
        when(element.getEventDefinitions()).thenReturn(eventDefinitions);
        EventDefinition eventDefinition = mock(EventDefinition.clreplaced);
        propertyWriter.addEventDefinition(eventDefinition);
        verify(eventDefinitions).add(eventDefinition);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testSetAbsoluteBounds() {
        Node<View, Edge> node = (Node<View, Edge>) super.createNode();
        Node<View, ?> dockSourceParentNode = mockNode(new Object(), org.kie.workbench.common.stunner.core.graph.content.Bounds.create(PARENT_ABSOLUTE_X1, PARENT_ABSOLUTE_Y1, PARENT_ABSOLUTE_X2, PARENT_ABSOLUTE_Y2));
        double dockSourceRelativeX1 = 15d;
        double dockSourceRelativeY1 = 20d;
        double dockSourceRelativeX2 = 50d;
        double dockSourceAbsoluteY2 = 45d;
        Node<View, ?> dockSourceNode = mockNode(new Object(), org.kie.workbench.common.stunner.core.graph.content.Bounds.create(dockSourceRelativeX1, dockSourceRelativeY1, dockSourceRelativeX2, dockSourceAbsoluteY2), dockSourceParentNode);
        Edge dockEdge = mock(Edge.clreplaced);
        when(dockEdge.getSourceNode()).thenReturn(dockSourceNode);
        Dock dock = mock(Dock.clreplaced);
        when(dockEdge.getContent()).thenReturn(dock);
        node.getInEdges().clear();
        node.getInEdges().add(dockEdge);
        propertyWriter.setAbsoluteBounds(node);
        Bounds shapeBounds = propertyWriter.getShape().getBounds();
        org.kie.workbench.common.stunner.core.graph.content.Bounds relativeBounds = node.getContent().getBounds();
        double dockSourceAbsoluteX = PARENT_ABSOLUTE_X1 + dockSourceRelativeX1;
        double dockSourceAbsoluteY = PARENT_ABSOLUTE_Y1 + dockSourceRelativeY1;
        replacedertEquals(dockSourceAbsoluteX + relativeBounds.getX(), shapeBounds.getX(), 0);
        replacedertEquals(dockSourceAbsoluteY + relativeBounds.getY(), shapeBounds.getY(), 0);
        replacedertEquals(relativeBounds.getWidth(), shapeBounds.getWidth(), 0);
        replacedertEquals(relativeBounds.getHeight(), shapeBounds.getHeight(), 0);
        verifyDockerInfoWreplacedet(relativeBounds);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testSetAbsoluteBoundsWhenDockedSourceNodeIsNotPresent() {
        // no dock source is set
        Node<View, Edge> node = (Node<View, Edge>) super.createNode();
        org.kie.workbench.common.stunner.core.graph.content.Bounds relativeBounds = node.getContent().getBounds();
        double absoluteX = PARENT_ABSOLUTE_X1 + relativeBounds.getUpperLeft().getX();
        double absoluteY = PARENT_ABSOLUTE_Y1 + relativeBounds.getUpperLeft().getY();
        propertyWriter.setAbsoluteBounds(node);
        Bounds shapeBounds = propertyWriter.getShape().getBounds();
        replacedertEquals(absoluteX, shapeBounds.getX(), 0);
        replacedertEquals(absoluteY, shapeBounds.getY(), 0);
        replacedertEquals(relativeBounds.getWidth(), shapeBounds.getWidth(), 0);
        replacedertEquals(relativeBounds.getHeight(), shapeBounds.getHeight(), 0);
        verifyDockerInfoWreplacedet(relativeBounds);
    }

    private void verifyDockerInfoWreplacedet(org.kie.workbench.common.stunner.core.graph.content.Bounds relativeBounds) {
        verify(featureMap).add(entryCaptor.capture());
        replacedertEquals(String.format("drools:dockerinfo=%s^%s|", relativeBounds.getUpperLeft().getX(), relativeBounds.getUpperLeft().getY()), entryCaptor.getValue().toString());
    }
}

16 View Complete Implementation : AppJsCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced AppJsCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new AppJsCreator(fileProcessor);
    }

    @Test
    public void replacedertOrder() {
        replacedertTrue(creator.order() == FileCreationOrder.APP_JS.order());
        replacedertTrue(creator.order() > FileCreationOrder.SRC_FOLDER.order());
    }

    @Test
    public void replacedertAppJsIsCreated() {
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path healthCheckJsPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./src/App.js"), healthCheckJsPath);
    }

    @Test
    public void replacederreplacedCopiesContentToFile() throws IOException {
        File f = folder.newFile("App.js");
        when(this.fileProcessor.loadResourceFromClreplacedPath(anyString())).thenReturn(new FileInputStream(f));
        when(this.fileProcessor.touch(any())).thenReturn(f);
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        creator.create(request);
        verify(this.fileProcessor, times(1)).copy(any(), eq(f));
    }
}

16 View Complete Implementation : HealthCheckJsCreatorTest.java
Copyright Mozilla Public License 2.0
Author : scotiabank
public clreplaced HealthCheckJsCreatorTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Mock
    private FileProcessor fileProcessor;

    @Captor
    private ArgumentCaptor<Path> pathCaptor;

    private FileCreator<ProjectCreation> creator;

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this);
        this.creator = new HealthCheckJsCreator(fileProcessor);
    }

    @Test
    public void replacedertOrder() {
        replacedertTrue(creator.order() == FileCreationOrder.HEALTHCHECK_JS.order());
        replacedertTrue(creator.order() > FileCreationOrder.INTEGRATIONTEST_FOLDER.order());
    }

    @Test
    public void replacedertHealthCheckJsIsCreated() {
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        this.creator.create(request);
        verify(this.fileProcessor, times(1)).touch(pathCaptor.capture());
        Path healthCheckJsPath = pathCaptor.getValue();
        replacedertEquals(Paths.get("./acceptanceTest/healthCheck.js"), healthCheckJsPath);
    }

    @Test
    public void replacederreplacedCopiesContentToFile() throws IOException {
        File f = folder.newFile("healthCheck.js");
        when(this.fileProcessor.loadResourceFromClreplacedPath(anyString())).thenReturn(new FileInputStream(f));
        when(this.fileProcessor.touch(any())).thenReturn(f);
        ProjectCreation request = ProjectCreation.builder().rootDir(".").build();
        creator.create(request);
        verify(this.fileProcessor, times(1)).copy(any(), eq(f));
    }
}