TestPlotViewPolicy.java

/*******************************************************************************
 * 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.fastplot.policy;

import gov.nasa.arc.mct.components.AbstractComponent;
import gov.nasa.arc.mct.components.FeedProvider;
import gov.nasa.arc.mct.fastplot.access.PolicyManagerAccess;
import gov.nasa.arc.mct.fastplot.view.PlotViewManifestation;
import gov.nasa.arc.mct.gui.View;
import gov.nasa.arc.mct.policy.ExecutionResult;
import gov.nasa.arc.mct.policy.Policy;
import gov.nasa.arc.mct.policy.PolicyContext;
import gov.nasa.arc.mct.services.component.PolicyManager;
import gov.nasa.arc.mct.services.component.ViewInfo;
import gov.nasa.arc.mct.services.component.ViewType;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class TestPlotViewPolicy {
	
	@Mock
	private AbstractComponent leafWithAFeedComponent;
	
	@Mock
	private AbstractComponent leafWithOutAFeedComponent;
	
	@Mock
	private AbstractComponent nonLeafComponent;
	
	@Mock
	private AbstractComponent compoundComponent;
	
	@Mock
	private AbstractComponent childCompoundComponent1;
	
	@Mock
	private AbstractComponent childCompoundComponent2;
	
	
	@Mock
	private PolicyManager mockPolicyManager;
	
	@Mock
	private FeedProvider provider;
	
	@BeforeMethod
	public void setup() {
		MockitoAnnotations.initMocks(this);
		Mockito.when(leafWithAFeedComponent.isLeaf()).thenReturn(true);
		Mockito.when(leafWithAFeedComponent.getCapability(FeedProvider.class)).thenReturn(provider);
		
		Mockito.when(leafWithOutAFeedComponent.isLeaf()).thenReturn(true);
		Mockito.when(leafWithOutAFeedComponent.getCapability(FeedProvider.class)).thenReturn(null);
		
		Mockito.when(nonLeafComponent.isLeaf()).thenReturn(false);
		Mockito.when(nonLeafComponent.getCapability(FeedProvider.class)).thenReturn(provider);
		
	}
		
	@Test
	public void testHasFeed() {
		Assert.assertTrue(PlotViewPolicy.hasFeed(leafWithAFeedComponent));
		Assert.assertFalse(PlotViewPolicy.hasFeed(leafWithOutAFeedComponent));
		Assert.assertTrue(PlotViewPolicy.hasFeed(nonLeafComponent));
	}
	
	@Test
	public void testIsCompoundComponentWithAtLeastOneChildThatIsALeafAndThatRequiresAPlot() {
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithAtLeastOneChildThatIsALeafAndThatRequiresAPlot(leafWithAFeedComponent));
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithAtLeastOneChildThatIsALeafAndThatRequiresAPlot(leafWithOutAFeedComponent));
		
		// setup compound components with a child that requires a plot.
		List<AbstractComponent> childComponents = new ArrayList<AbstractComponent>();
		childComponents.add(leafWithAFeedComponent);	
		childComponents.add(leafWithOutAFeedComponent);
		Mockito.when(compoundComponent.getComponents()).thenReturn(childComponents);
		
		// we now have two children. One with a feed and one without. 
		Assert.assertTrue(PlotViewPolicy.isCompoundComponentWithAtLeastOneChildThatIsALeafAndThatRequiresAPlot(compoundComponent));
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithCompoundChildrenThatRequirePlots(compoundComponent));
		
		// change our feed with a child to one without. 
		childComponents.remove(leafWithAFeedComponent);
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithAtLeastOneChildThatIsALeafAndThatRequiresAPlot(compoundComponent));	
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithCompoundChildrenThatRequirePlots(compoundComponent));
	}
	
	@Test
	public void testIsCompoundComponentWithCompoundChildrenThatRequirePlots() {
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithCompoundChildrenThatRequirePlots(leafWithAFeedComponent));
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithCompoundChildrenThatRequirePlots(leafWithOutAFeedComponent));
		
		List<AbstractComponent> childComponents = new ArrayList<AbstractComponent>();
		childComponents.add(childCompoundComponent1);	
		childComponents.add(childCompoundComponent2);
		Mockito.when(compoundComponent.getComponents()).thenReturn(childComponents);
		Mockito.when(compoundComponent.isLeaf()).thenReturn(false);
		
		
		List<AbstractComponent> childCompound1Children = new ArrayList<AbstractComponent>();
		List<AbstractComponent> childCompound2Children = new ArrayList<AbstractComponent>();
		
		childCompound1Children.add(leafWithAFeedComponent);	
		childCompound2Children.add(leafWithOutAFeedComponent);
		
		Mockito.when(childCompoundComponent1.getComponents()).thenReturn(childCompound1Children);
		Mockito.when(childCompoundComponent2.getComponents()).thenReturn(childCompound2Children);
		Mockito.when(childCompoundComponent1.isLeaf()).thenReturn(false);
		Mockito.when(childCompoundComponent2.isLeaf()).thenReturn(false);
		
		Assert.assertTrue(PlotViewPolicy.isCompoundComponentWithCompoundChildrenThatRequirePlots(compoundComponent));
		
		Mockito.when(childCompoundComponent1.getComponents()).thenReturn(childCompound2Children);
		
		Assert.assertFalse(PlotViewPolicy.isCompoundComponentWithCompoundChildrenThatRequirePlots(compoundComponent));
	}
	
	@Test
	public void testGetNonCompoundPlotComponents() {
		(new PolicyManagerAccess()).setPolicyManager(mockPolicyManager);
		Mockito.when(mockPolicyManager.execute(Mockito.anyString(), Mockito.any(PolicyContext.class))).thenReturn(
				new ExecutionResult(null,true,"test"));
		
		AbstractComponent[][] components = PlotViewPolicy.getPlotComponents(leafWithAFeedComponent, true);
		Assert.assertEquals(components.length,1);
		Assert.assertSame(components[0][0], leafWithAFeedComponent);
		
		components = PlotViewPolicy.getPlotComponents(leafWithOutAFeedComponent, true);
		Assert.assertEquals(components.length,0);
		
		// setup compound components with a child that requires a plot.
		List<AbstractComponent> childComponents = new ArrayList<AbstractComponent>();
		childComponents.add(leafWithAFeedComponent);	
		childComponents.add(leafWithOutAFeedComponent);
		Mockito.when(compoundComponent.getComponents()).thenReturn(childComponents);
	}
	
	@Test
	public void testGetCompoundPlotComponents() {
		(new PolicyManagerAccess()).setPolicyManager(mockPolicyManager);
		Mockito.when(mockPolicyManager.execute(Mockito.anyString(), Mockito.any(PolicyContext.class))).thenReturn(
				new ExecutionResult(null,true,"test"));
		// setup compound components with a child that requires a plot.
		List<AbstractComponent> childComponents = new ArrayList<AbstractComponent>();
		childComponents.add(leafWithAFeedComponent);	
		childComponents.add(leafWithOutAFeedComponent);
		Mockito.when(compoundComponent.getComponents()).thenReturn(childComponents);
		
		AbstractComponent[][] components = PlotViewPolicy.getPlotComponents(compoundComponent, true);
		Assert.assertEquals(components.length,1);
		Assert.assertSame(components[0][0], leafWithAFeedComponent);
	}
	
	private AbstractComponent createComponentWithNoFeed() {
		AbstractComponent comp = Mockito.mock(AbstractComponent.class);
		Mockito.when(comp.isLeaf()).thenReturn(true);
		
		return comp;
	}
	
	private AbstractComponent createComponentWithFeed(String displayName) {
		AbstractComponent comp = Mockito.mock(AbstractComponent.class);
		Mockito.when(comp.isLeaf()).thenReturn(true);
		Mockito.when(comp.getDisplayName()).thenReturn(displayName);
		Mockito.when(comp.getCapability(FeedProvider.class)).thenReturn(provider);
		
		return comp;
	}
	
	private AbstractComponent createComponentWithChildren(int numChildren, String prefix) {
		AbstractComponent comp = Mockito.mock(AbstractComponent.class);
		List<AbstractComponent> childComponents = new ArrayList<AbstractComponent>();
		Mockito.when(comp.getComponents()).thenReturn(childComponents);
		
		childComponents.add(createComponentWithNoFeed());
		
		for (int i =0; i < numChildren; i++) {
			childComponents.add(createComponentWithFeed(prefix+Integer.toString(i)));
		}
		
		return comp;
	}
	
	@Test
	public void testRejectCanvasView() throws Exception {
		(new PolicyManagerAccess()).setPolicyManager(mockPolicyManager);
		AbstractComponent comp = Mockito.mock(AbstractComponent.class);
		PlotViewPolicy policy = new PlotViewPolicy();
		PolicyContext context = new PolicyContext();
		context.setProperty(PolicyContext.PropertyName.TARGET_VIEW_INFO.getName(), new ViewInfo(PlotViewManifestation.class,"",ViewType.CENTER));
		Method m = policy.getClass().getDeclaredMethod("rejectCanvasView", PolicyContext.class, AbstractComponent.class);
		m.setAccessible(true);
		Mockito.when(comp.isLeaf()).thenReturn(false);
		Assert.assertEquals(m.invoke(policy, context, comp), Boolean.FALSE, "direct access to plot view role should always be true");
		context.setProperty(PolicyContext.PropertyName.VIEW_TYPE.getName(), ViewType.CENTER);
		Assert.assertEquals(m.invoke(policy, context, comp), Boolean.TRUE, "collections must not support canvas view roles");
		Mockito.when(comp.isLeaf()).thenReturn(true);
		Assert.assertEquals(m.invoke(policy, context, comp), Boolean.FALSE, "leafs must support canvas view roles");

	}
	
	@Test
	public void testGetCompoundPlotComponentsWithChildren() {
		(new PolicyManagerAccess()).setPolicyManager(mockPolicyManager);
		Mockito.when(mockPolicyManager.execute(Mockito.anyString(), Mockito.any(PolicyContext.class))).thenReturn(
				new ExecutionResult(null,true,"test"));
		// setup compound components with a child that requires a plot.
		List<AbstractComponent> childComponents = new ArrayList<AbstractComponent>();
		String start = "A";
		for (int i = 0; i < 12; i++) {
			AbstractComponent child = createComponentWithChildren(12, start);
			childComponents.add(child);
			start+="'";
		}
		Mockito.when(compoundComponent.getComponents()).thenReturn(childComponents);
		// also verify the sequence of components names to make sure the group is being divided equally
		
		AbstractComponent[][] components = PlotViewPolicy.getPlotComponents(compoundComponent, true);
		Assert.assertEquals(components.length,10);
		int offset = 0;
		for (AbstractComponent[] col:components) {
			Assert.assertEquals(col.length,12);
			String sequence = "A";
			for (AbstractComponent component : col) {
				Assert.assertEquals(component.getDisplayName(), sequence+Integer.valueOf(offset));
				sequence+="'";
			}
			offset++;
		}
	}
	
	@Test
	public void testExecute() {
		Policy policy = new PlotViewPolicy();
		PolicyContext context; 
		
		ViewInfo plotViewInfo = new ViewInfo(PlotViewManifestation.class, "Plot", ViewType.OBJECT);
		
		// Plot views should be allowed for leaf component with a feed
		context = new PolicyContext();
		context.setProperty(PolicyContext.PropertyName.TARGET_VIEW_INFO.getName(),
				plotViewInfo);
		context.setProperty(PolicyContext.PropertyName.TARGET_COMPONENT.getName(),
				leafWithAFeedComponent);		
		Assert.assertTrue(policy.execute(context).getStatus());

		// ...but not without a feed
		context = new PolicyContext();
		context.setProperty(PolicyContext.PropertyName.TARGET_VIEW_INFO.getName(),
				plotViewInfo);
		context.setProperty(PolicyContext.PropertyName.TARGET_COMPONENT.getName(),
				leafWithOutAFeedComponent);		
		Assert.assertFalse(policy.execute(context).getStatus());
		
		// Plot view policy should not reject non-plot, ever
		for (AbstractComponent ac : new AbstractComponent[] { leafWithAFeedComponent, leafWithOutAFeedComponent, nonLeafComponent} ) {
			for (ViewType vt : ViewType.values()) {
				ViewInfo someViewInfo = new ViewInfo(NonPlotView.class, "NonPlot", vt); 
				context = new PolicyContext();
				context.setProperty(PolicyContext.PropertyName.TARGET_VIEW_INFO.getName(),
						someViewInfo);
				context.setProperty(PolicyContext.PropertyName.TARGET_COMPONENT.getName(),
						ac);		
				Assert.assertTrue(policy.execute(context).getStatus());
			}
		}
	}
	
	private static class NonPlotView extends View {	
		private static final long serialVersionUID = 3389103274105732666L;

		@SuppressWarnings("unused") // Constructor needed to satisfy Viewinfo
		public NonPlotView(AbstractComponent ac, ViewInfo vi) {
			super(ac,vi);
		}
	}
}