AbstractPerspectiveTest.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.ide.workspace.perspectives.general;

import com.google.gwt.user.client.ui.AcceptsOneWidget;
import com.google.gwt.user.client.ui.FlowPanel;
import com.google.gwt.user.client.ui.SimpleLayoutPanel;
import com.google.gwt.user.client.ui.SimplePanel;
import com.google.gwt.user.client.ui.SplitLayoutPanel;
import com.google.gwtmockito.GwtMockitoTestRunner;
import com.google.web.bindery.event.shared.EventBus;

import org.eclipse.che.ide.api.constraints.Constraints;
import org.eclipse.che.ide.api.editor.AbstractEditorPresenter;
import org.eclipse.che.ide.api.event.ActivePartChangedEvent;
import org.eclipse.che.ide.api.parts.PartPresenter;
import org.eclipse.che.ide.api.parts.PartStack;
import org.eclipse.che.ide.api.parts.PartStackView;
import org.eclipse.che.ide.api.parts.PartStackView.TabPosition;
import org.eclipse.che.ide.part.PartStackPresenter;
import org.eclipse.che.ide.workspace.PartStackPresenterFactory;
import org.eclipse.che.ide.workspace.PartStackViewFactory;
import org.eclipse.che.ide.workspace.WorkBenchControllerFactory;
import org.eclipse.che.ide.workspace.WorkBenchPartController;
import org.eclipse.che.providers.DynaProvider;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Matchers;
import org.mockito.Mock;

import javax.validation.constraints.NotNull;
import javax.ws.rs.NotSupportedException;
import java.util.Arrays;

import static org.eclipse.che.ide.api.parts.PartStackType.EDITING;
import static org.eclipse.che.ide.api.parts.PartStackType.INFORMATION;
import static org.eclipse.che.ide.api.parts.PartStackType.NAVIGATION;
import static org.eclipse.che.ide.api.parts.PartStackView.TabPosition.BELOW;
import static org.eclipse.che.ide.api.parts.PartStackView.TabPosition.LEFT;
import static org.eclipse.che.ide.api.parts.PartStackView.TabPosition.RIGHT;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

/**
 * @author Dmitry Shnurenko
 */
@RunWith(GwtMockitoTestRunner.class)
public class AbstractPerspectiveTest {

    private final static String SOME_TEXT = "someText";

    //constructor mocks
    @Mock
    private PerspectiveViewImpl        view;
    @Mock
    private PartStackPresenterFactory  stackPresenterFactory;
    @Mock
    private PartStackViewFactory       partStackViewFactory;
    @Mock
    private WorkBenchControllerFactory controllerFactory;
    @Mock
    private EventBus                   eventBus;

    //additional mocks
    @Mock
    private FlowPanel               panel;
    @Mock
    private SplitLayoutPanel        layoutPanel;
    @Mock
    private SimplePanel             simplePanel;
    @Mock
    private SimpleLayoutPanel       simpleLayoutPanel;
    @Mock
    private PartStackView           partStackView;
    @Mock
    private PartStackPresenter      extraPartStackPresenter;
    @Mock
    private PartStackPresenter      partStackPresenter;
    @Mock
    private WorkBenchPartController workBenchController;
    @Mock
    private PartPresenter           partPresenter;
    @Mock
    private Constraints             constraints;
    @Mock
    private PartPresenter           navigationPart;
    @Mock
    private PartPresenter           activePart;
    @Mock
    private AbstractEditorPresenter editorPart;
    @Mock
    private DynaProvider            dynaProvider;

    private AbstractPerspective perspective;

    @Before
    public void setUp() throws Exception {
        when(view.getLeftPanel()).thenReturn(panel);
        when(view.getRightPanel()).thenReturn(panel);
        when(view.getBottomPanel()).thenReturn(panel);

        when(view.getSplitPanel()).thenReturn(layoutPanel);

        when(view.getNavigationPanel()).thenReturn(simplePanel);
        when(view.getInformationPanel()).thenReturn(simpleLayoutPanel);
        when(view.getToolPanel()).thenReturn(simplePanel);

        when(controllerFactory.createController(Matchers.<SplitLayoutPanel>anyObject(),
                                                Matchers.<SimplePanel>anyObject())).thenReturn(workBenchController);

        when(partStackViewFactory.create(Matchers.<TabPosition>anyObject(),
                                         Matchers.<FlowPanel>anyObject())).thenReturn(partStackView);

        when(stackPresenterFactory.create(Matchers.<PartStackView>anyObject(),
                                          Matchers.<WorkBenchPartController>anyObject())).thenReturn(partStackPresenter);

        perspective =
                new DummyPerspective(view, stackPresenterFactory, partStackViewFactory, controllerFactory, eventBus,
                        extraPartStackPresenter, partStackPresenter, dynaProvider);
    }

    @Test
    public void activePartShouldBeOpened() {
        perspective.openActivePart(INFORMATION);

        verify(partStackPresenter).openPreviousActivePart();
    }

    @Test
    public void constructorShouldBeVerified() {
        verify(view).getLeftPanel();
        verify(view).getBottomPanel();
        verify(view).getRightPanel();

        verify(partStackViewFactory).create(LEFT, panel);
        verify(partStackViewFactory).create(BELOW, panel);
        verify(partStackViewFactory).create(RIGHT, panel);

        verify(view, times(3)).getSplitPanel();
        verify(view).getNavigationPanel();
        verify(controllerFactory, times(2)).createController(layoutPanel, simplePanel);
        verify(controllerFactory).createController(layoutPanel, simpleLayoutPanel);
        verify(stackPresenterFactory, times(3)).create(partStackView, workBenchController);

        verify(eventBus).addHandler(ActivePartChangedEvent.TYPE, perspective);
    }

    @Test
    public void partShouldBeRemoved() {
        when(partStackPresenter.containsPart(partPresenter)).thenReturn(true);

        perspective.removePart(partPresenter);

        verify(partStackPresenter).removePart(partPresenter);
    }

    @Test
    public void perspectiveStateShouldBeStored() {
        perspective.onActivePartChanged(new ActivePartChangedEvent(editorPart));

        perspective.storeState();

        verify(editorPart).storeState();
    }

    @Test
    public void perspectiveStateShouldBeRestored() {
        perspective.onActivePartChanged(new ActivePartChangedEvent(editorPart));
        perspective.storeState();

        perspective.restoreState();

        verify(editorPart).restoreState();
    }

    @Test
    public void partShouldBeHided() {
        when(partStackPresenter.containsPart(partPresenter)).thenReturn(true);

        perspective.hidePart(partPresenter);

        verify(partStackPresenter).minimize();
    }

    @Test
    public void partShouldBeMaximized() {
        perspective.onMaximize(partStackPresenter);

        verify(partStackPresenter).maximize();
    }

    @Test
    public void partShouldBeCollapsed() {
        perspective.onMaximize(extraPartStackPresenter);

        verify(partStackPresenter, times(3)).collapse();
        verify(extraPartStackPresenter).maximize();
    }

    @Test
    public void activePartShouldBeSet() {
        when(partStackPresenter.containsPart(partPresenter)).thenReturn(true);

        perspective.setActivePart(partPresenter);

        verify(partStackPresenter).setActivePart(partPresenter);
    }

    @Test
    public void activePartShouldBeSetWithType() {
        perspective.setActivePart(partPresenter, INFORMATION);

        verify(partStackPresenter).setActivePart(partPresenter);
    }

    @Test
    public void nullShouldBeReturnedWhenPartIsNotFound() {
        PartStack partStack = perspective.findPartStackByPart(partPresenter);

        assertSame(partStack, null);
    }

    @Test
    public void nullShouldBeFound() {
        when(partStackPresenter.containsPart(partPresenter)).thenReturn(true);

        PartStack partStack = perspective.findPartStackByPart(partPresenter);

        assertSame(partStack, partStackPresenter);
    }

    @Test
    public void partShouldBeAddedWithoutConstraints() {
        perspective.addPart(partPresenter, INFORMATION);

        verify(partStackPresenter).addPart(partPresenter, null);
    }

    @Test
    public void partShouldBeAddedWithConstraints() {
        perspective.addPart(partPresenter, INFORMATION, constraints);

        verify(partStackPresenter).addPart(partPresenter, constraints);
    }

    @Test
    public void partStackShouldBeReturned() {
        perspective.addPart(partPresenter, INFORMATION);

        PartStack partStack = perspective.getPartStack(INFORMATION);

        assertSame(partStack, partStackPresenter);
    }

    @Test
    public void partShouldBeAddedWithRules() {
        when(partPresenter.getRules()).thenReturn(Arrays.asList(SOME_TEXT));

        perspective.addPart(partPresenter, INFORMATION);

        verify(partStackPresenter).addPart(partPresenter, null);
    }


    public static class DummyPerspective extends AbstractPerspective {

        public DummyPerspective(@NotNull PerspectiveViewImpl view,
                                @NotNull PartStackPresenterFactory stackPresenterFactory,
                                @NotNull PartStackViewFactory partViewFactory,
                                @NotNull WorkBenchControllerFactory controllerFactory,
                                @NotNull EventBus eventBus,

                                PartStackPresenter extraPartStackPresenter,
                                PartStackPresenter editingPartStackPresenter,

                                DynaProvider dynaProvider) {
            super(SOME_TEXT, view, stackPresenterFactory, partViewFactory, controllerFactory, eventBus, dynaProvider);

            if (extraPartStackPresenter != null) {
                partStacks.put(NAVIGATION, extraPartStackPresenter);
            }

            if (editingPartStackPresenter != null) {
                partStacks.put(EDITING, editingPartStackPresenter);
            }
        }

        @Override
        public String getPerspectiveId() {
            return SOME_TEXT;
        }

        @Override
        public String getPerspectiveName() {
            return "Dummy";
        }

        @Override
        public void go(@NotNull AcceptsOneWidget container) {
            throw new NotSupportedException("This method will be tested in the class which extends AbstractPerspective");
        }
    }

}