SshKeyManagerPresenterTest.java

/*******************************************************************************
 * Copyright (c) 2012-2016 Codenvy, S.A.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 *******************************************************************************/
package org.eclipse.che.ide.ext.git.ssh.client.manage;

import com.google.gwt.safehtml.shared.SafeHtml;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.AcceptsOneWidget;
import com.google.gwtmockito.GwtMockitoTestRunner;

import org.eclipse.che.api.promises.client.Operation;
import org.eclipse.che.api.promises.client.OperationException;
import org.eclipse.che.api.promises.client.Promise;
import org.eclipse.che.api.promises.client.PromiseError;
import org.eclipse.che.api.promises.client.js.JsPromiseError;
import org.eclipse.che.api.ssh.gwt.client.SshServiceClient;
import org.eclipse.che.api.ssh.shared.dto.SshPairDto;
import org.eclipse.che.ide.api.app.AppContext;
import org.eclipse.che.ide.api.notification.NotificationManager;
import org.eclipse.che.ide.api.notification.StatusNotification;
import org.eclipse.che.ide.ext.git.ssh.client.SshLocalizationConstant;
import org.eclipse.che.ide.ext.git.ssh.client.SshResources;
import org.eclipse.che.ide.ext.git.ssh.client.upload.UploadSshKeyPresenter;
import org.eclipse.che.ide.rest.DtoUnmarshallerFactory;
import org.eclipse.che.ide.ui.dialogs.CancelCallback;
import org.eclipse.che.ide.ui.dialogs.ConfirmCallback;
import org.eclipse.che.ide.ui.dialogs.DialogFactory;
import org.eclipse.che.ide.ui.dialogs.InputCallback;
import org.eclipse.che.ide.ui.dialogs.confirm.ConfirmDialog;
import org.eclipse.che.ide.ui.dialogs.input.InputDialog;
import org.eclipse.che.ide.ui.dialogs.message.MessageDialog;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import java.util.ArrayList;
import java.util.List;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.RETURNS_DEFAULTS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

/**
 * Testing {@link SshKeyManagerPresenter} functionality.
 *
 * @author Roman Nikitenko
 */
@RunWith(GwtMockitoTestRunner.class)
public class SshKeyManagerPresenterTest {
    public static final String GITHUB_HOST = "github.com";

    @Captor
    private ArgumentCaptor<AsyncCallback<Void>> asyncCallbackCaptor;

    @Captor
    private ArgumentCaptor<ConfirmCallback> confirmCallbackCaptor;

    @Captor
    private ArgumentCaptor<CancelCallback> cancelCallbackCaptor;

    @Captor
    private ArgumentCaptor<InputCallback> inputCallbackCaptor;

    @Captor
    private ArgumentCaptor<Operation<Void>> operationVoidCapture;

    @Captor
    private ArgumentCaptor<Operation<List<SshPairDto>>> operationSshPairDTOsCapture;

    @Captor
    private ArgumentCaptor<Operation<SshPairDto>> operationSshPairDTOCapture;

    @Captor
    private ArgumentCaptor<Operation<PromiseError>> operationErrorCapture;

    private Promise<Void>             voidPromise;
    private Promise<SshPairDto>       sshPairDTOPromise;
    private Promise<List<SshPairDto>> sshPairDTOsPromise;

    @Mock
    private AppContext              appContext;
    @Mock
    private DtoUnmarshallerFactory  dtoUnmarshallerFactory;
    @Mock
    private DialogFactory           dialogFactory;
    @Mock
    private SshKeyManagerView       view;
    @Mock
    private SshServiceClient        service;
    @Mock
    private SshLocalizationConstant constant;
    @Mock
    private SshResources            resources;
    @Mock
    private UploadSshKeyPresenter   uploadSshKeyPresenter;
    @Mock
    private NotificationManager     notificationManager;
    @InjectMocks
    private SshKeyManagerPresenter  presenter;

    @Mock
    SshPairDto sshPairDto;

    @Before
    @SuppressWarnings("unchecked")
    public void setUp() throws Exception {
        voidPromise = createPromiseMock();
        sshPairDTOsPromise = createPromiseMock();
        sshPairDTOPromise = createPromiseMock();

        when(service.getPairs(anyString())).thenReturn(sshPairDTOsPromise);
        when(service.deletePair(anyString(), anyString())).thenReturn(voidPromise);
        when(service.generatePair(anyString(), anyString())).thenReturn(sshPairDTOPromise);
    }

    private Promise createPromiseMock() {
        return mock(Promise.class, new Answer() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                if (invocation.getMethod().getReturnType().isInstance(invocation.getMock())) {
                    return invocation.getMock();
                }
                return RETURNS_DEFAULTS.answer(invocation);
            }
        });
    }

    @Test
    public void testGo() {
        AcceptsOneWidget container = mock(AcceptsOneWidget.class);

        presenter.go(container);

        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(container).setWidget(eq(view));
    }

    @Test
    public void testOnViewClickedWhenGetPublicKeyIsSuccess() {
        when(sshPairDto.getPublicKey()).thenReturn("publicKey");
        MessageDialog messageDialog = mock(MessageDialog.class);
        when(dialogFactory.createMessageDialog(anyString(), anyString(), (ConfirmCallback)anyObject())).thenReturn(messageDialog);

        presenter.onViewClicked(sshPairDto);

        verify(dialogFactory).createMessageDialog(anyString(), eq("publicKey"), (ConfirmCallback)anyObject());
        verify(messageDialog).show();
    }

    @Test
    public void testOnDeleteClickedWhenDeleteKeyConfirmed() {
        when(sshPairDto.getService()).thenReturn(SshKeyManagerPresenter.GIT_SSH_SERVICE);
        when(sshPairDto.getName()).thenReturn(GITHUB_HOST);
        SafeHtml safeHtml = mock(SafeHtml.class);
        ConfirmDialog confirmDialog = mock(ConfirmDialog.class);
        when(constant.deleteSshKeyQuestion(anyString())).thenReturn(safeHtml);
        when(safeHtml.asString()).thenReturn("");
        when(dialogFactory.createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(confirmDialog);

        presenter.onDeleteClicked(sshPairDto);

        verify(dialogFactory).createConfirmDialog(anyString(), anyString(), confirmCallbackCaptor.capture(), (CancelCallback)anyObject());
        ConfirmCallback confirmCallback = confirmCallbackCaptor.getValue();
        confirmCallback.accepted();

        verify(confirmDialog).show();
        verify(service).deletePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
    }

    @Test
    public void testOnDeleteClickedWhenDeleteKeyCanceled() {
        SafeHtml safeHtml = mock(SafeHtml.class);
        ConfirmDialog confirmDialog = mock(ConfirmDialog.class);
        when(constant.deleteSshKeyQuestion(anyString())).thenReturn(safeHtml);
        when(safeHtml.asString()).thenReturn("");
        when(dialogFactory.createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(confirmDialog);

        presenter.onDeleteClicked(sshPairDto);

        verify(dialogFactory).createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), cancelCallbackCaptor.capture());
        CancelCallback cancelCallback = cancelCallbackCaptor.getValue();
        cancelCallback.cancelled();

        verify(confirmDialog).show();
        verify(service, never()).deletePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), anyString());
    }

    @Test
    public void testOnDeleteClickedWhenDeleteKeyIsSuccess() throws OperationException {
        when(sshPairDto.getService()).thenReturn(SshKeyManagerPresenter.GIT_SSH_SERVICE);
        when(sshPairDto.getName()).thenReturn(GITHUB_HOST);
        SafeHtml safeHtml = mock(SafeHtml.class);
        ConfirmDialog confirmDialog = mock(ConfirmDialog.class);
        when(constant.deleteSshKeyQuestion(anyString())).thenReturn(safeHtml);
        when(safeHtml.asString()).thenReturn("");
        when(dialogFactory.createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(confirmDialog);

        presenter.onDeleteClicked(sshPairDto);

        verify(dialogFactory).createConfirmDialog(anyString(), anyString(), confirmCallbackCaptor.capture(), (CancelCallback)anyObject());
        ConfirmCallback confirmCallback = confirmCallbackCaptor.getValue();
        confirmCallback.accepted();

        verify(voidPromise).then(operationVoidCapture.capture());
        operationVoidCapture.getValue().apply(null);

        verify(confirmDialog).show();
        verify(service).deletePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
    }

    @Test
    public void testOnDeleteClickedWhenDeleteKeyIsFailure() throws OperationException {
        when(sshPairDto.getService()).thenReturn(SshKeyManagerPresenter.GIT_SSH_SERVICE);
        when(sshPairDto.getName()).thenReturn(GITHUB_HOST);
        SafeHtml safeHtml = mock(SafeHtml.class);
        ConfirmDialog confirmDialog = mock(ConfirmDialog.class);
        when(constant.deleteSshKeyQuestion(anyString())).thenReturn(safeHtml);
        when(safeHtml.asString()).thenReturn("");
        when(dialogFactory.createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(confirmDialog);

        presenter.onDeleteClicked(sshPairDto);

        verify(dialogFactory).createConfirmDialog(anyString(), anyString(), confirmCallbackCaptor.capture(), (CancelCallback)anyObject());
        ConfirmCallback confirmCallback = confirmCallbackCaptor.getValue();
        confirmCallback.accepted();

        verify(voidPromise).catchError(operationErrorCapture.capture());
        operationErrorCapture.getValue().apply(JsPromiseError.create(""));

        verify(confirmDialog).show();
        verify(service).deletePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), anyString());
        verify(notificationManager).notify(anyString(), eq(StatusNotification.Status.FAIL), eq(true));
        verify(service, never()).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
    }

    @Test
    public void testShouldRefreshKeysAfterSuccessfulDeleteKey() throws OperationException {
        when(sshPairDto.getService()).thenReturn(SshKeyManagerPresenter.GIT_SSH_SERVICE);
        when(sshPairDto.getName()).thenReturn(GITHUB_HOST);
        SafeHtml safeHtml = mock(SafeHtml.class);
        ConfirmDialog confirmDialog = mock(ConfirmDialog.class);
        List<SshPairDto> sshPairDtoArray = new ArrayList<>();
        when(constant.deleteSshKeyQuestion(anyString())).thenReturn(safeHtml);
        when(safeHtml.asString()).thenReturn("");
        when(dialogFactory.createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(confirmDialog);

        presenter.onDeleteClicked(sshPairDto);

        verify(dialogFactory).createConfirmDialog(anyString(), anyString(), confirmCallbackCaptor.capture(), (CancelCallback)anyObject());
        ConfirmCallback confirmCallback = confirmCallbackCaptor.getValue();
        confirmCallback.accepted();

        verify(voidPromise).then(operationVoidCapture.capture());
        operationVoidCapture.getValue().apply(null);

        verify(sshPairDTOsPromise).then(operationSshPairDTOsCapture.capture());
        operationSshPairDTOsCapture.getValue().apply(sshPairDtoArray);

        verify(confirmDialog).show();
        verify(service).deletePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(view).setPairs(eq(sshPairDtoArray));
    }

    @Test
    public void testFailedRefreshKeysAfterSuccessfulDeleteKey() throws OperationException {
        when(sshPairDto.getService()).thenReturn(SshKeyManagerPresenter.GIT_SSH_SERVICE);
        when(sshPairDto.getName()).thenReturn(GITHUB_HOST);
        SafeHtml safeHtml = mock(SafeHtml.class);
        ConfirmDialog confirmDialog = mock(ConfirmDialog.class);
        List<SshPairDto> sshPairDtoArray = new ArrayList<>();
        when(constant.deleteSshKeyQuestion(anyString())).thenReturn(safeHtml);
        when(safeHtml.asString()).thenReturn("");
        when(dialogFactory.createConfirmDialog(anyString(), anyString(), (ConfirmCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(confirmDialog);

        presenter.onDeleteClicked(sshPairDto);

        verify(dialogFactory).createConfirmDialog(anyString(), anyString(), confirmCallbackCaptor.capture(), (CancelCallback)anyObject());
        ConfirmCallback confirmCallback = confirmCallbackCaptor.getValue();
        confirmCallback.accepted();

        verify(voidPromise).then(operationVoidCapture.capture());
        operationVoidCapture.getValue().apply(null);

        verify(sshPairDTOsPromise).catchError(operationErrorCapture.capture());
        operationErrorCapture.getValue().apply(JsPromiseError.create(""));

        verify(confirmDialog).show();
        verify(service).deletePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(view, never()).setPairs(eq(sshPairDtoArray));
        verify(notificationManager).notify(anyString(), any(StatusNotification.Status.class), anyBoolean());
    }

    @Test
    public void testShouldRefreshKeysAfterSuccessfulUploadKey() throws OperationException {
        List<SshPairDto> sshPairDtoArray = new ArrayList<>();

        presenter.onUploadClicked();

        verify(uploadSshKeyPresenter).showDialog(asyncCallbackCaptor.capture());
        AsyncCallback<Void> asyncCallback = asyncCallbackCaptor.getValue();
        asyncCallback.onSuccess(null);

        verify(sshPairDTOsPromise).then(operationSshPairDTOsCapture.capture());
        operationSshPairDTOsCapture.getValue().apply(sshPairDtoArray);

        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(view).setPairs(eq(sshPairDtoArray));
    }


    @Test
    public void testFailedRefreshKeysAfterSuccessfulUploadKey() throws OperationException {
        List<SshPairDto> sshPairDtoArray = new ArrayList<>();

        presenter.onUploadClicked();

        verify(uploadSshKeyPresenter).showDialog(asyncCallbackCaptor.capture());
        AsyncCallback<Void> asyncCallback = asyncCallbackCaptor.getValue();
        asyncCallback.onSuccess(null);

        verify(sshPairDTOsPromise).catchError(operationErrorCapture.capture());
        operationErrorCapture.getValue().apply(JsPromiseError.create(""));

        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(view, never()).setPairs(eq(sshPairDtoArray));
    }


    @Test
    public void testOnGenerateClickedWhenUserConfirmGenerateKey() {
        InputDialog inputDialog = mock(InputDialog.class);
        when(dialogFactory.createInputDialog(anyString(), anyString(), (InputCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(inputDialog);

        presenter.onGenerateClicked();

        verify(dialogFactory).createInputDialog(anyString(), anyString(), inputCallbackCaptor.capture(), (CancelCallback)anyObject());
        InputCallback inputCallback = inputCallbackCaptor.getValue();
        inputCallback.accepted(GITHUB_HOST);

        verify(service).generatePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
    }

    @Test
    public void testOnGenerateClickedWhenUserCancelGenerateKey() {
        InputDialog inputDialog = mock(InputDialog.class);
        when(dialogFactory.createInputDialog(anyString(), anyString(), (InputCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(inputDialog);

        presenter.onGenerateClicked();

        verify(dialogFactory).createInputDialog(anyString(), anyString(), (InputCallback)anyObject(), cancelCallbackCaptor.capture());
        CancelCallback cancelCallback = cancelCallbackCaptor.getValue();
        cancelCallback.cancelled();

        verify(service, never()).generatePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
    }

    @Test
    public void testOnGenerateClickedWhenGenerateKeyIsFailed() throws OperationException {
        InputDialog inputDialog = mock(InputDialog.class);
        when(dialogFactory.createInputDialog(anyString(), anyString(), (InputCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(inputDialog);

        presenter.onGenerateClicked();

        verify(dialogFactory).createInputDialog(anyString(), anyString(),
                                                inputCallbackCaptor.capture(), cancelCallbackCaptor.capture());
        InputCallback inputCallback = inputCallbackCaptor.getValue();
        inputCallback.accepted(GITHUB_HOST);

        verify(sshPairDTOPromise).catchError(operationErrorCapture.capture());
        operationErrorCapture.getValue().apply(JsPromiseError.create(""));

        verify(service).generatePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
        verify(service, never()).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(view, never()).setPairs((List<SshPairDto>)anyObject());
        verify(notificationManager).notify(anyString(), anyString(), any(StatusNotification.Status.class), anyBoolean());
    }

    @Test
    public void testShouldRefreshKeysAfterSuccessfulGenerateKey() throws OperationException {
        List<SshPairDto> sshPairDtoArray = new ArrayList<>();
        InputDialog inputDialog = mock(InputDialog.class);
        when(dialogFactory.createInputDialog(anyString(), anyString(), (InputCallback)anyObject(), (CancelCallback)anyObject()))
                .thenReturn(inputDialog);

        presenter.onGenerateClicked();

        verify(dialogFactory).createInputDialog(anyString(), anyString(),
                                                inputCallbackCaptor.capture(), cancelCallbackCaptor.capture());
        InputCallback inputCallback = inputCallbackCaptor.getValue();
        inputCallback.accepted(GITHUB_HOST);

        verify(sshPairDTOPromise).then(operationSshPairDTOCapture.capture());
        operationSshPairDTOCapture.getValue().apply(null);

        verify(sshPairDTOsPromise).then(operationSshPairDTOsCapture.capture());
        operationSshPairDTOsCapture.getValue().apply(sshPairDtoArray);

        verify(service).generatePair(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE), eq(GITHUB_HOST));
        verify(service).getPairs(Matchers.eq(SshKeyManagerPresenter.GIT_SSH_SERVICE));
        verify(view).setPairs(eq(sshPairDtoArray));
    }
}