/*******************************************************************************
* Mission Control Technologies, Copyright (c) 2009-2012, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* The MCT platform is licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* MCT includes source code licensed under additional open source licenses. See
* the MCT Open Source Licenses file included with this distribution or the About
* MCT Licenses dialog available at runtime from the MCT Help menu for additional
* information.
*******************************************************************************/
package gov.nasa.arc.mct.gui.actions;
import gov.nasa.arc.mct.components.AbstractComponent;
import gov.nasa.arc.mct.defaults.view.MCTHousingViewManifestation;
import gov.nasa.arc.mct.gui.ActionContext;
import gov.nasa.arc.mct.gui.ContextAwareAction;
import gov.nasa.arc.mct.gui.View;
import gov.nasa.arc.mct.gui.housing.MCTContentArea;
import gov.nasa.arc.mct.platform.spi.PersistenceProvider;
import gov.nasa.arc.mct.platform.spi.Platform;
import gov.nasa.arc.mct.platform.spi.PlatformAccess;
import gov.nasa.arc.mct.platform.spi.WindowManager;
import gov.nasa.arc.mct.services.component.ViewInfo;
import java.awt.event.ActionEvent;
import java.util.Map;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
/**
* Unit tests for Refresh action
* @author vwoeltje
*
*/
public class TestRefresh {
private Platform platform;
private Platform mockPlatform;
@Mock private ActionContext mockContext;
@Mock private MCTHousingViewManifestation mockHousing;
@Mock private MCTContentArea mockContentArea;
@Mock private AbstractComponent mockComponent;
@Mock private View mockView;
@Mock private ViewInfo mockViewInfo;
@Mock private ActionEvent mockEvent;
@Mock private WindowManager mockWindowManager;
@Mock private PersistenceProvider mockPersistence;
@Mock private View mockInspector;
@BeforeClass
public void setup() {
platform = PlatformAccess.getPlatform();
mockPlatform = Mockito.mock(Platform.class);
new PlatformAccess().setPlatform(mockPlatform);
}
@AfterClass
public void teardown() {
new PlatformAccess().setPlatform(platform);
}
@BeforeMethod
public void setupMethod() {
MockitoAnnotations.initMocks(this);
Mockito.when(mockContext.getWindowManifestation()).thenReturn(mockHousing);
Mockito.when(mockHousing.getContentArea()).thenReturn(mockContentArea);
Mockito.when(mockContentArea.getHousedViewManifestation()).thenReturn(mockView);
Mockito.when(mockInspector.getHousedViewManifestation()).thenReturn(mockView);
Mockito.when(mockHousing.getManifestedComponent()).thenReturn(mockComponent);
Mockito.when(mockView.getManifestedComponent()).thenReturn(mockComponent);
Mockito.when(mockView.getInfo()).thenReturn(mockViewInfo);
Mockito.when(mockPlatform.getWindowManager()).thenReturn(mockWindowManager);
Mockito.when(mockPlatform.getPersistenceProvider()).thenReturn(mockPersistence);
Mockito.when(mockPersistence.getComponent(Mockito.anyString())).thenReturn(mockComponent);
Mockito.when(mockComponent.getComponentId()).thenReturn("mock");
}
// Test various 'canHandle' responses
@Test
public void testCanHandle() {
// Mock context has a content area, so we should be able to handle this
Assert.assertTrue(new RefreshAction().canHandle(mockContext));
// With no housing, action can't be handled
ActionContext noHousingContext = Mockito.mock(ActionContext.class);
Mockito.when(noHousingContext.getWindowManifestation()).thenReturn(null);
Assert.assertFalse(new RefreshAction().canHandle(noHousingContext));
// With no content area, action can't be handled
ActionContext noContentContext = Mockito.mock(ActionContext.class);
MCTHousingViewManifestation noContentHousing = Mockito.mock(MCTHousingViewManifestation.class);
Mockito.when(noContentContext.getWindowManifestation()).thenReturn(noContentHousing);
Mockito.when(noContentHousing.getContentArea()).thenReturn(null);
Assert.assertFalse(new RefreshAction().canHandle(noHousingContext));
}
@Test
public void testIsEnabled() {
// Should always be enabled if canHandle
ContextAwareAction refresh = new RefreshAction();
// Verify precondition (also verifed in previous test)
// canHandle is a necessary part of ContextAwareAction life cycle
Assert.assertTrue(refresh.canHandle(mockContext));
// Verify that refresh menu item is enabled
Assert.assertTrue(refresh.isEnabled());
}
@Test
public void testActionPerformedNonDirty() {
Mockito.when(mockComponent.isDirty()).thenReturn(false);
// The newer version of the component, for which a view should be created
AbstractComponent newerComponent = Mockito.mock(AbstractComponent.class);
Mockito.when(mockPersistence.getComponent("mock")).thenReturn(newerComponent);
// Similarly, newer version of the view
View newerView = Mockito.mock(View.class);
Mockito.when(mockViewInfo.createView(newerComponent)).thenReturn(newerView);
// Create refresh action, obey life cycle
ContextAwareAction refresh = new RefreshAction();
Assert.assertTrue(refresh.canHandle(mockContext));
// Verify preconditions
Mockito.verifyZeroInteractions(mockWindowManager);
Mockito.verifyZeroInteractions(mockContentArea);
Mockito.verifyZeroInteractions(mockViewInfo);
// Perform action
refresh.actionPerformed(mockEvent);
// Verify that view was updated
Mockito.verify(mockViewInfo).createView(newerComponent);
Mockito.verify(mockContentArea).setOwnerComponentCanvasManifestation(newerView);
// Verify that user was NOT prompted
Mockito.verifyZeroInteractions(mockWindowManager);
}
@Test (dataProvider = "truthData")
public void testActionPerformedDirty(final boolean confirmed) {
Mockito.when(mockComponent.isDirty()).thenReturn(true);
// The newer version of the component, for which a view should be created
AbstractComponent newerComponent = Mockito.mock(AbstractComponent.class);
Mockito.when(mockPersistence.getComponent("mock")).thenReturn(newerComponent);
// Similarly, newer version of the view
View newerView = Mockito.mock(View.class);
Mockito.when(mockViewInfo.createView(newerComponent)).thenReturn(newerView);
// Mock user response to dialog
Mockito.when(mockWindowManager.showInputDialog(Mockito.anyString(), Mockito.anyString(), Mockito.<Object[]>any(), Mockito.any(), Mockito.<Map<String,Object>>any())).thenAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Object[] options = (Object[]) invocation.getArguments()[2];
return confirmed ? options[0] : options[1]; // options[0] presumed to mean "OK"
}
});
// Create refresh action, obey life cycle
ContextAwareAction refresh = new RefreshAction();
Assert.assertTrue(refresh.canHandle(mockContext));
// Verify preconditions
Mockito.verifyZeroInteractions(mockWindowManager);
Mockito.verifyZeroInteractions(mockContentArea);
Mockito.verifyZeroInteractions(mockViewInfo);
// Perform action
refresh.actionPerformed(mockEvent);
// Verify that dialog was invoked
Mockito.verify(mockWindowManager).showInputDialog(Mockito.anyString(), Mockito.anyString(), Mockito.<Object[]>any(), Mockito.any(), Mockito.<Map<String,Object>>any());
// Verify that view was updated only if confirmed
if (confirmed) {
Mockito.verify(mockViewInfo).createView(newerComponent);
Mockito.verify(mockContentArea).setOwnerComponentCanvasManifestation(newerView);
} else {
Mockito.verify(mockViewInfo, Mockito.never()).createView(Mockito.<AbstractComponent>any());
Mockito.verify(mockContentArea, Mockito.never()).setOwnerComponentCanvasManifestation(Mockito.<View>any());
}
// Verify that user was NOT prompted
Mockito.verifyZeroInteractions(mockWindowManager);
}
@DataProvider
public Object[][] truthData() {
return new Object[][] { {true} , {false} };
}
// An Inspector has some differences from ContentArea - verify that it is refreshable too
@Test
public void testInspector() {
// Verify interactions with a mock inspector
Mockito.when(mockContext.getWindowManifestation()).thenReturn(mockInspector);
// Verify that refresh can handle, is enabled for an Inspector
ContextAwareAction refresh = new RefreshAction();
Assert.assertTrue(refresh.canHandle(mockContext));
Assert.assertTrue(refresh.isEnabled());
// Verify actionPerformed triggers appropriate method
refresh.actionPerformed(mockEvent);
Mockito.verify(mockInspector).setHousedViewManifestation(mockViewInfo);
}
}