/*******************************************************************************
* 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 elemental.json.Json;
import elemental.json.JsonArray;
import elemental.json.JsonObject;
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.inject.Provider;
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.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.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Matchers;
import org.mockito.Mock;
import static org.mockito.Mockito.never;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import java.util.ArrayList;
import java.util.List;
import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* @author Evgen Vidolob
*/
@RunWith(GwtMockitoTestRunner.class)
public class AbstractPerspectivePersistenceTest {
//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 partStackPresenter;
@Mock
private WorkBenchPartController workBenchController;
@Mock
private PartPresenter partPresenter;
@Mock
private Constraints constraints;
@Mock
private PartPresenter activePart;
@Mock
private AbstractEditorPresenter editorPart;
@Mock
private DynaProvider dynaProvider;
@Mock
private Provider<PartPresenter> partProvider;
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(partStackPresenter.getPartStackState()).thenReturn(PartStack.State.NORMAL);
when(controllerFactory.createController(Matchers.<SplitLayoutPanel>anyObject(),
Matchers.<SimplePanel>anyObject())).thenReturn(workBenchController);
when(partStackViewFactory.create(Matchers.<PartStackView.TabPosition>anyObject(),
Matchers.<FlowPanel>anyObject())).thenReturn(partStackView);
when(stackPresenterFactory.create(Matchers.<PartStackView>anyObject(),
Matchers.<WorkBenchPartController>anyObject())).thenReturn(partStackPresenter);
perspective =
new AbstractPerspectiveTest.DummyPerspective(view, stackPresenterFactory, partStackViewFactory, controllerFactory, eventBus,
null, partStackPresenter, dynaProvider);
perspective.onActivePartChanged(new ActivePartChangedEvent(activePart));
}
@Test
public void shouldStoreActivePart() throws Exception {
JsonObject state = perspective.getState();
assertThat(state).isNotNull();
String activePart = state.getString("ACTIVE_PART");
assertThat(activePart).isNotNull().isNotEmpty();
}
@Test
public void shouldStoreParts() throws Exception {
JsonObject state = perspective.getState();
JsonObject partStacks = state.getObject("PART_STACKS");
assertThat(partStacks).isNotNull();
}
@Test
public void shouldNotStoreEditorPartStack() throws Exception {
JsonObject state = perspective.getState();
JsonObject partStacks = state.getObject("PART_STACKS");
String[] keys = partStacks.keys();
assertThat(keys).containsOnly("INFORMATION", "NAVIGATION", "TOOLING");
}
@Test
public void shouldRestorePartStackSize() throws Exception {
JsonObject state = Json.createObject();
JsonObject parts = Json.createObject();
state.put("PART_STACKS", parts);
JsonObject partStack = Json.createObject();
parts.put("INFORMATION", partStack);
JsonArray partsArray = Json.createArray();
partStack.put("PARTS", partsArray);
JsonObject part = Json.createObject();
partsArray.set(0, part);
part.put("CLASS", "foo.Bar");
partStack.put("SIZE", 142);
// partStackPresenter.getParts() must return non empty list
final List<PartPresenter> partPresenters = new ArrayList<>();
partPresenters.add(partPresenter);
when(partStackPresenter.getParts()).thenAnswer(new Answer<List<? extends PartPresenter>>() {
@Override
public List<? extends PartPresenter> answer(InvocationOnMock invocationOnMock) throws Throwable {
return partPresenters;
}
});
perspective.loadState(state);
verify(workBenchController).setSize(142d);
}
@Test
public void shouldRestoreHiddenPartStackState() throws Exception {
JsonObject state = Json.createObject();
JsonObject parts = Json.createObject();
state.put("PART_STACKS", parts);
JsonObject partStack = Json.createObject();
parts.put("INFORMATION", partStack);
partStack.put("HIDDEN", true);
perspective.loadState(state);
verify(workBenchController).setHidden(true);
}
@Test
@Ignore //TODO
public void shouldRestoreOpenedParts() throws Exception {
JsonObject state = Json.createObject();
JsonObject parts = Json.createObject();
state.put("PART_STACKS", parts);
JsonObject partStack = Json.createObject();
parts.put("INFORMATION", partStack);
JsonArray partsArray = Json.createArray();
partStack.put("PARTS", partsArray);
JsonObject part = Json.createObject();
partsArray.set(0, part);
part.put("CLASS", "foo.Bar");
when(dynaProvider.<PartPresenter>getProvider(anyString())).thenReturn(partProvider);
when(partProvider.get()).thenReturn(partPresenter);
perspective.loadState(state);
verify(dynaProvider).getProvider("foo.Bar");
verify(partProvider).get();
verify(partStackPresenter).addPart(partPresenter);
}
@Test
public void shouldRestoreMaximizedPartStack() throws Exception {
JsonObject state = Json.createObject();
JsonObject parts = Json.createObject();
state.put("PART_STACKS", parts);
JsonObject partStack = Json.createObject();
parts.put("INFORMATION", partStack);
partStack.put("STATE", PartStack.State.MAXIMIZED.name());
JsonArray partsArray = Json.createArray();
partStack.put("PARTS", partsArray);
JsonObject part = Json.createObject();
partsArray.set(0, part);
part.put("CLASS", "foo.Bar");
partStack.put("SIZE", 142);
// partStackPresenter.getParts() must return non empty list
final List<PartPresenter> partPresenters = new ArrayList<>();
partPresenters.add(partPresenter);
when(partStackPresenter.getParts()).thenAnswer(new Answer<List<? extends PartPresenter>>() {
@Override
public List<? extends PartPresenter> answer(InvocationOnMock invocationOnMock) throws Throwable {
return partPresenters;
}
});
perspective.loadState(state);
verify(workBenchController, never()).setSize(142d);
}
}