DebuggerPresenterTest.java

/*******************************************************************************
 * Copyright (c) 2012-2017 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.plugin.debugger.ide.debug;

import com.google.gwt.user.client.ui.AcceptsOneWidget;

import org.eclipse.che.api.debug.shared.dto.LocationDto;
import org.eclipse.che.api.debug.shared.dto.SimpleValueDto;
import org.eclipse.che.api.debug.shared.model.Location;
import org.eclipse.che.api.debug.shared.model.MutableVariable;
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.ide.api.filetypes.FileType;
import org.eclipse.che.ide.api.filetypes.FileTypeRegistry;
import org.eclipse.che.ide.api.notification.NotificationManager;
import org.eclipse.che.ide.api.parts.WorkspaceAgent;
import org.eclipse.che.ide.api.resources.VirtualFile;
import org.eclipse.che.ide.api.debug.Breakpoint;
import org.eclipse.che.ide.api.debug.BreakpointManager;
import org.eclipse.che.ide.debug.Debugger;
import org.eclipse.che.ide.debug.DebuggerDescriptor;
import org.eclipse.che.ide.debug.DebuggerManager;
import org.eclipse.che.ide.dto.DtoFactory;
import org.eclipse.che.ide.ui.toolbar.ToolbarPresenter;
import org.eclipse.che.plugin.debugger.ide.BaseTest;
import org.eclipse.che.plugin.debugger.ide.DebuggerLocalizationConstant;
import org.eclipse.che.plugin.debugger.ide.DebuggerResources;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;

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

import static org.eclipse.che.ide.api.notification.StatusNotification.DisplayMode.FLOAT_MODE;
import static org.eclipse.che.ide.api.notification.StatusNotification.DisplayMode.NOT_EMERGE_MODE;
import static org.eclipse.che.ide.api.notification.StatusNotification.Status.FAIL;
import static org.eclipse.che.ide.api.notification.StatusNotification.Status.PROGRESS;
import static org.eclipse.che.ide.api.notification.StatusNotification.Status.SUCCESS;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

/**
 * Testing {@link DebuggerPresenter} functionality.
 *
 * @author Dmytro Nochevnov
 */
public class DebuggerPresenterTest extends BaseTest {
    public static final String ERROR_MESSAGE = "error message";

    @Mock
    private DebuggerView                 view;
    @Mock
    private DebuggerLocalizationConstant constant;
    @Mock
    private BreakpointManager            breakpointManager;
    @Mock
    private NotificationManager          notificationManager;
    @Mock
    private DebuggerResources            debuggerResources;
    @Mock
    @DebuggerToolbar
    private ToolbarPresenter             debuggerToolbar;
    @Mock
    private DtoFactory                   dtoFactory;
    @Mock
    private DebuggerManager              debuggerManager;
    @Mock
    private WorkspaceAgent               workspaceAgent;
    @Mock
    private FileTypeRegistry             fileTypeRegistry;

    @Mock
    private Debugger        debugger;
    @Mock
    private MutableVariable selectedVariable;
    @Mock
    private VirtualFile     file;

    @Mock
    private Promise<String>         promiseString;
    @Mock
    private Promise<SimpleValueDto> promiseValue;
    @Mock
    private Promise<Void>           promiseVoid;
    @Mock
    private PromiseError            promiseError;


    @Captor
    private ArgumentCaptor<Operation<PromiseError>>   operationPromiseErrorCaptor;
    @Captor
    private ArgumentCaptor<Operation<Void>>           operationVoidCaptor;
    @Captor
    private ArgumentCaptor<Operation<String>>         operationStringCaptor;
    @Captor
    private ArgumentCaptor<Operation<SimpleValueDto>> operationValueCaptor;

    private DebuggerPresenter presenter;

    @Before
    public void setup() {
        doReturn(debugger).when(debuggerManager).getActiveDebugger();
        doReturn(ERROR_MESSAGE).when(promiseError).getMessage();

        presenter = spy(new DebuggerPresenter(view, constant, breakpointManager, notificationManager, debuggerResources, debuggerToolbar,
                                              debuggerManager, workspaceAgent));
        doNothing().when(presenter).showDebuggerPanel();

        presenter.onSelectedVariableElement(selectedVariable);

        FileType fileType = mock(FileType.class);
        doReturn("java").when(fileType).getExtension();
        doReturn(fileType).when(fileTypeRegistry).getFileTypeByFile(eq(file));
    }

    @Test
    public void testGo() {
        AcceptsOneWidget container = mock(AcceptsOneWidget.class);
        List<Breakpoint> breakpoints = new ArrayList<>();

        doReturn(breakpoints).when(breakpointManager).getBreakpointList();
        doReturn(container).when(view).getDebuggerToolbarPanel();

        presenter.go(container);

        verify(view).setBreakpoints(breakpoints);
        verify(view).setVariables(any());
        verify(container).setWidget(view);
        verify(debuggerToolbar).go(container);
    }

    @Test
    public void testOnExpandVariablesTree() throws OperationException {
        SimpleValueDto valueDto = mock(SimpleValueDto.class);

        List<MutableVariable> rootVariables = mock(List.class);
        doReturn(true).when(rootVariables).isEmpty();
        doReturn(rootVariables).when(selectedVariable).getVariables();

        doReturn(promiseValue).when(debugger).getValue(selectedVariable);
        doReturn(promiseValue).when(promiseValue).then((Operation<SimpleValueDto>)any());

        presenter.onExpandVariablesTree();

        verify(promiseValue).then(operationValueCaptor.capture());
        operationValueCaptor.getValue().apply(valueDto);
        verify(view).setVariablesIntoSelectedVariable(any());
        verify(view).updateSelectedVariable();

        verify(promiseValue).catchError(operationPromiseErrorCaptor.capture());
        operationPromiseErrorCaptor.getValue().apply(promiseError);
        notificationManager.notify(any(), eq(ERROR_MESSAGE), eq(FAIL), eq(FLOAT_MODE));
        verify(constant).failedToGetVariableValueTitle();
    }

    @Test
    public void testShowAndUpdateView() {
        presenter.showAndUpdateView();
        verify(view).setVMName(eq(""));
    }

    @Test
    public void testOnDebuggerAttached() {
        DebuggerDescriptor debuggerDescriptor = mock(DebuggerDescriptor.class);
        final String address = "address";
        doReturn(address).when(debuggerDescriptor).getAddress();

        doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>)any());

        String title = "title";
        doReturn(title).when(this.constant).debuggerConnectingTitle(address);

        presenter.onDebuggerAttached(debuggerDescriptor, promiseVoid);
        notificationManager.notify(eq(address), eq(PROGRESS), eq(FLOAT_MODE));
    }

    @Test
    public void testOnDebuggerDisconnected() {
        final String address = "";
        String title = "title";
        doReturn(title).when(this.constant).debuggerDisconnectedTitle();
        String description = "description";
        doReturn(description).when(this.constant).debuggerDisconnectedDescription(address);

        presenter.onDebuggerDisconnected();
        notificationManager.notify(eq(title), eq(description), eq(SUCCESS), eq(NOT_EMERGE_MODE));
    }

    @Test
    public void testOnPreIn() {
        presenter.onPreStepInto();

        verify(view).setVariables(any());
        verify(view).setVMName(eq(""));
        verify(view).setExecutionPoint(eq(null));
    }

    @Test
    public void testOnPreOut() {
        presenter.onPreStepOut();

        verify(view).setVariables(any());
        verify(view).setVMName(eq(""));
        verify(view).setExecutionPoint(eq(null));
    }

    @Test
    public void testOnPreOver() {
        presenter.onPreStepOver();

        verify(view).setVariables(any());
        verify(view).setVMName(eq(""));
        verify(view).setExecutionPoint(eq(null));
    }

    @Test
    public void testOnPreResume() {
        presenter.onPreResume();

        verify(view).setVariables(any());
        verify(view).setVMName(eq(""));
        verify(view).setExecutionPoint(eq(null));
    }

    @Test
    public void testOnBreakpointAdded() {
        Breakpoint breakpoint = mock(Breakpoint.class);

        List<Breakpoint> breakpoints = new ArrayList<>();
        doReturn(breakpoints).when(breakpointManager).getBreakpointList();

        presenter.onBreakpointAdded(breakpoint);
        verify(presenter).updateBreakpoints();
        verify(breakpointManager, times(2)).getBreakpointList();
        verify(view).setBreakpoints(any());
    }

    @Test
    public void testOnBreakpointDeleted() {
        Breakpoint breakpoint = mock(Breakpoint.class);

        List<Breakpoint> breakpoints = new ArrayList<>();
        doReturn(breakpoints).when(breakpointManager).getBreakpointList();

        presenter.onBreakpointDeleted(breakpoint);
        verify(breakpointManager, times(2)).getBreakpointList();
        verify(view).setBreakpoints(any());
    }

    @Test
    public void testOnAllBreakpointsDeleted() {
        List<Breakpoint> breakpoints = new ArrayList<>();
        doReturn(breakpoints).when(breakpointManager).getBreakpointList();

        presenter.onAllBreakpointsDeleted();
        verify(breakpointManager, times(2)).getBreakpointList();
        verify(view).setBreakpoints(any());
    }

    @Test
    public void testOnBreakpointStopped() {
        String filePath = "filePath";
        String className = "className";
        int lineNumber = 40;

        LocationDto executionPoint = mock(LocationDto.class);
        doReturn(executionPoint).when(dtoFactory).createDto(LocationDto.class);

        doReturn(promiseString).when(debugger).dumpStackFrame();
        doReturn(promiseString).when(promiseString).then((Operation<String>)any());

        presenter.onBreakpointStopped(filePath, className, lineNumber);

        verify(presenter).showAndUpdateView();
        verify(view).setExecutionPoint(any(Location.class));
    }

    @Test
    public void testOnValueChanged() {
        doReturn(promiseString).when(debugger).dumpStackFrame();
        doReturn(promiseString).when(promiseString).then((Operation<String>)any());

        ArrayList<String> path = new ArrayList<>();
        String newValue = "newValue";
        presenter.onValueChanged(path, newValue);
    }
}