Content of file ViewTemplateSupplierImpl_Test.java

/*******************************************************************************
 * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * Lucas Koehler - initial API and implementation
 ******************************************************************************/
package org.eclipse.emf.ecp.view.template.service;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.isNull;
import static org.mockito.Matchers.notNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
import org.eclipse.emf.ecp.view.spi.model.VControl;
import org.eclipse.emf.ecp.view.spi.model.VDomainModelReference;
import org.eclipse.emf.ecp.view.spi.model.VDomainModelReferenceSegment;
import org.eclipse.emf.ecp.view.spi.model.VElement;
import org.eclipse.emf.ecp.view.spi.model.VFeatureDomainModelReferenceSegment;
import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
import org.eclipse.emf.ecp.view.template.model.VTStyle;
import org.eclipse.emf.ecp.view.template.model.VTStyleProperty;
import org.eclipse.emf.ecp.view.template.model.VTStyleSelector;
import org.eclipse.emf.ecp.view.template.model.VTTemplateFactory;
import org.eclipse.emf.ecp.view.template.model.VTViewTemplate;
import org.eclipse.emf.ecp.view.template.selector.domainmodelreference.model.VTDomainModelReferenceSelector;
import org.eclipse.emf.ecp.view.template.selector.domainmodelreference.model.VTDomainmodelreferenceFactory;
import org.eclipse.emfforms.spi.core.services.segments.EMFFormsSegmentGenerator;
import org.eclipse.emfforms.spi.core.services.segments.LegacyDmrToRootEClass;
import org.junit.Before;
import org.junit.Test;

/**
 * Unit test cases for the {@link ViewTemplateSupplierImpl}.
 *
 * @author Lucas Koehler
 *
 */
public class ViewTemplateSupplierImpl_Test {

	private ViewTemplateSupplierImpl templateSupplier;
	private LegacyDmrToRootEClass dmrToRootEClass;

	@Before
	public void setup() {
		templateSupplier = new ViewTemplateSupplierImpl();
		dmrToRootEClass = mock(LegacyDmrToRootEClass.class);
		templateSupplier.setLegacyDmrToRootEClass(dmrToRootEClass);
	}

	@Test
	public void testGetTemplateModels() {
		final VTViewTemplate template1 = VTTemplateFactory.eINSTANCE.createViewTemplate();
		final VTViewTemplate template2 = VTTemplateFactory.eINSTANCE.createViewTemplate();
		final VTStyle style1 = VTTemplateFactory.eINSTANCE.createStyle();
		template1.getStyles().add(style1);
		final LinkedHashSet<VTViewTemplate> templates = new LinkedHashSet<VTViewTemplate>();
		templates.add(template1);
		templates.add(template2);

		templateSupplier.setViewTemplates(templates);

		final Iterator<VTViewTemplate> iterator = templateSupplier.getViewTemplates().iterator();
		final VTViewTemplate copy1 = iterator.next();
		assertNotSame(template1, copy1);
		assertTrue(EcoreUtil.equals(template1, copy1));
		final VTViewTemplate copy2 = iterator.next();
		assertNotSame(template2, copy2);
		assertTrue(EcoreUtil.equals(template2, copy2));
	}

	@Test
	public void testNoTemplateModel() {
		final Map<VTStyleProperty, Double> styleProperties = templateSupplier.getStyleProperties(mock(VElement.class),
			mock(ViewModelContext.class));
		assertTrue(styleProperties.isEmpty());
	}

	@Test
	public void testVElementIsNull() {
		final List<VTViewTemplate> templates = createListWithTwoTemplates();
		templates.get(0).getStyles().add(mockStyle(1d));
		templates.get(1).getStyles().add(mockStyle(1d));
		templateSupplier.setViewTemplates(new LinkedHashSet<VTViewTemplate>(templates));

		final Map<VTStyleProperty, Double> styleProperties = templateSupplier.getStyleProperties(null,
			mock(ViewModelContext.class));
		assertTrue(styleProperties.isEmpty());
	}

	@Test
	public void testViewModelContextIsNull() {
		final List<VTViewTemplate> templates = createListWithTwoTemplates();
		templates.get(0).getStyles().add(mockStyle(1d));
		templates.get(1).getStyles().add(mockStyle(1d));
		templateSupplier.setViewTemplates(new LinkedHashSet<VTViewTemplate>(templates));

		final Map<VTStyleProperty, Double> styleProperties = templateSupplier.getStyleProperties(mock(VElement.class),
			null);
		assertTrue(styleProperties.isEmpty());
	}

	/**
	 * Test that only applicable style properties are returned.
	 */
	@Test
	public void testApplicableStyleProperties() {
		final List<VTViewTemplate> templates = createListWithTwoTemplates();
		final VTStyle style1 = mockStyle(1d);
		final VTStyleProperty styleProperty1 = style1.getProperties().get(0);
		final VTStyle style2 = mockStyle(2d);
		final VTStyleProperty styleProperty2 = style2.getProperties().get(0);
		templates.get(0).getStyles().add(style1);
		templates.get(0).getStyles().add(mockStyle(VTStyleSelector.NOT_APPLICABLE));
		templates.get(1).getStyles().add(style2);

		final VControl vElement = mock(VControl.class);
		final VDomainModelReference dmr = mock(VDomainModelReference.class);
		when(vElement.getDomainModelReference()).thenReturn(dmr);
		final ViewModelContext viewModelContext = mock(ViewModelContext.class);
		templateSupplier.setViewTemplates(new LinkedHashSet<VTViewTemplate>(templates));

		final Map<VTStyleProperty, Double> styleProperties = templateSupplier.getStyleProperties(vElement,
			viewModelContext);

		assertEquals(2, styleProperties.size());
		assertTrue(styleProperties.containsKey(styleProperty1));
		assertTrue(styleProperties.containsKey(styleProperty2));
	}

	/** Test that style properties are associated with their correct specificities. */
	@Test
	public void testSpecifities() {
		final List<VTViewTemplate> templates = createListWithTwoTemplates();
		final VTStyle style1 = mockStyle(3d);
		final VTStyleProperty styleProperty1 = style1.getProperties().get(0);
		final VTStyle style2 = mockStyle(1d);
		final VTStyleProperty styleProperty2 = style2.getProperties().get(0);
		templates.get(0).getStyles().add(style1);
		templates.get(1).getStyles().add(style2);

		when(styleProperty1.equalStyles(styleProperty2)).thenReturn(true);
		when(styleProperty2.equalStyles(styleProperty1)).thenReturn(true);

		templateSupplier.setViewTemplates(new LinkedHashSet<VTViewTemplate>(templates));

		final VControl vElement = mock(VControl.class);
		final VDomainModelReference dmr = mock(VDomainModelReference.class);
		when(vElement.getDomainModelReference()).thenReturn(dmr);
		final ViewModelContext viewModelContext = mock(ViewModelContext.class);
		final Map<VTStyleProperty, Double> styleProperties = templateSupplier.getStyleProperties(vElement,
			viewModelContext);

		assertEquals(2, styleProperties.size());
		assertTrue(styleProperties.containsKey(styleProperty1));
		assertEquals(new Double(3d), styleProperties.get(styleProperty1));
		assertTrue(styleProperties.containsKey(styleProperty2));
		assertEquals(new Double(1d), styleProperties.get(styleProperty2));
	}

	@Test
	public void generateSegments() {
		final VTViewTemplate template = VTTemplateFactory.eINSTANCE.createViewTemplate();
		final VTStyle style = VTTemplateFactory.eINSTANCE.createStyle();
		final VTDomainModelReferenceSelector dmrSelector = VTDomainmodelreferenceFactory.eINSTANCE
			.createDomainModelReferenceSelector();
		final VDomainModelReference dmr = VViewFactory.eINSTANCE.createDomainModelReference();
		dmrSelector.setDomainModelReference(dmr);
		style.setSelector(dmrSelector);
		template.getStyles().add(style);

		final EMFFormsSegmentGenerator segmentGenerator = mock(EMFFormsSegmentGenerator.class);
		templateSupplier.setEMFFormsSegmentGenerator(segmentGenerator);
		final List<VDomainModelReferenceSegment> segmentList = new LinkedList<>();
		final VFeatureDomainModelReferenceSegment segment0 = VViewFactory.eINSTANCE
			.createFeatureDomainModelReferenceSegment();
		final VFeatureDomainModelReferenceSegment segment1 = VViewFactory.eINSTANCE
			.createFeatureDomainModelReferenceSegment();
		final VFeatureDomainModelReferenceSegment segment2 = VViewFactory.eINSTANCE
			.createFeatureDomainModelReferenceSegment();
		segmentList.add(segment0);
		segmentList.add(segment1);
		segmentList.add(segment2);

		final EClass rootEClass = EcoreFactory.eINSTANCE.createEClass();
		when(dmrToRootEClass.getRootEClass(dmr)).thenReturn(Optional.of(rootEClass));
		when(segmentGenerator.generateSegments(dmr)).thenReturn(segmentList);

		templateSupplier.generateSegments(template);

		assertEquals("Wrong number of generated segments", 3, dmr.getSegments().size()); //$NON-NLS-1$
		assertSame("Wrong order of segments", segment0, dmr.getSegments().get(0)); //$NON-NLS-1$
		assertSame("Wrong order of segments", segment1, dmr.getSegments().get(1)); //$NON-NLS-1$
		assertSame("Wrong order of segments", segment2, dmr.getSegments().get(2)); //$NON-NLS-1$
		assertSame("Incorrect root EClass set", rootEClass, dmrSelector.getRootEClass()); //$NON-NLS-1$
	}

	/** Segments are generated but root EClass cannot be determined. */
	@Test
	public void generateSegments_noRootEClass() {
		final VTViewTemplate template = VTTemplateFactory.eINSTANCE.createViewTemplate();
		final VTStyle style = VTTemplateFactory.eINSTANCE.createStyle();
		final VTDomainModelReferenceSelector dmrSelector = VTDomainmodelreferenceFactory.eINSTANCE
			.createDomainModelReferenceSelector();
		final VDomainModelReference dmr = VViewFactory.eINSTANCE.createDomainModelReference();
		dmrSelector.setDomainModelReference(dmr);
		style.setSelector(dmrSelector);
		template.getStyles().add(style);

		final EMFFormsSegmentGenerator segmentGenerator = mock(EMFFormsSegmentGenerator.class);
		templateSupplier.setEMFFormsSegmentGenerator(segmentGenerator);
		final List<VDomainModelReferenceSegment> segmentList = new LinkedList<>();
		final VFeatureDomainModelReferenceSegment segment = VViewFactory.eINSTANCE
			.createFeatureDomainModelReferenceSegment();
		segmentList.add(segment);

		when(dmrToRootEClass.getRootEClass(dmr)).thenReturn(Optional.empty());
		when(segmentGenerator.generateSegments(dmr)).thenReturn(segmentList);

		templateSupplier.generateSegments(template);

		assertEquals("No segments should be set", 0, dmr.getSegments().size()); //$NON-NLS-1$
		assertNull("No root EClass should be set", dmrSelector.getRootEClass()); //$NON-NLS-1$
	}

	/** Root EClass can be determined but no segments are generated. */
	@Test
	public void generateSegments_noSegmentsGenerated() {
		final VTViewTemplate template = VTTemplateFactory.eINSTANCE.createViewTemplate();
		final VTStyle style = VTTemplateFactory.eINSTANCE.createStyle();
		final VTDomainModelReferenceSelector dmrSelector = VTDomainmodelreferenceFactory.eINSTANCE
			.createDomainModelReferenceSelector();
		final VFeaturePathDomainModelReference featureDmr = VViewFactory.eINSTANCE
			.createFeaturePathDomainModelReference();
		featureDmr.setDomainModelEFeature(EcorePackage.Literals.ENAMED_ELEMENT__NAME);
		dmrSelector.setDomainModelReference(featureDmr);
		style.setSelector(dmrSelector);
		template.getStyles().add(style);

		when(dmrToRootEClass.getRootEClass(any())).thenReturn(Optional.of(mock(EClass.class)));
		final EMFFormsSegmentGenerator segmentGenerator = mock(EMFFormsSegmentGenerator.class);
		when(segmentGenerator.generateSegments(featureDmr)).thenReturn(Collections.emptyList());
		templateSupplier.setEMFFormsSegmentGenerator(segmentGenerator);

		templateSupplier.generateSegments(template);

		assertEquals("Wrong number of generated segments", 0, featureDmr.getSegments().size()); //$NON-NLS-1$
		assertNull("No root EClass should be set if no segments could be generated", dmrSelector.getRootEClass()); //$NON-NLS-1$
	}

	@Test
	public void generateSegments_dmrWithExistingSegments() {
		final VTViewTemplate template = VTTemplateFactory.eINSTANCE.createViewTemplate();
		final VTStyle style = VTTemplateFactory.eINSTANCE.createStyle();
		final VTDomainModelReferenceSelector dmrSelector = VTDomainmodelreferenceFactory.eINSTANCE
			.createDomainModelReferenceSelector();
		final VFeaturePathDomainModelReference featureDmr = VViewFactory.eINSTANCE
			.createFeaturePathDomainModelReference();
		featureDmr.setDomainModelEFeature(EcorePackage.Literals.ENAMED_ELEMENT__NAME);
		final VFeatureDomainModelReferenceSegment existingSegment = VViewFactory.eINSTANCE
			.createFeatureDomainModelReferenceSegment();
		featureDmr.getSegments().add(existingSegment);
		dmrSelector.setDomainModelReference(featureDmr);
		dmrSelector.setRootEClass(EcorePackage.Literals.ENAMED_ELEMENT);
		style.setSelector(dmrSelector);
		template.getStyles().add(style);

		final EMFFormsSegmentGenerator segmentGenerator = mock(EMFFormsSegmentGenerator.class);
		templateSupplier.setEMFFormsSegmentGenerator(segmentGenerator);

		templateSupplier.generateSegments(template);

		verify(segmentGenerator, never()).generateSegments(any(VDomainModelReference.class));
		assertEquals("Wrong number of segments", 1, featureDmr.getSegments().size()); //$NON-NLS-1$
		assertSame("Wrong segment", existingSegment, featureDmr.getSegments().get(0)); //$NON-NLS-1$
		assertSame("Incorrect root EClass set", EcorePackage.Literals.ENAMED_ELEMENT, dmrSelector.getRootEClass()); //$NON-NLS-1$
	}

	private static VTStyle mockStyle(double specificity) {
		final VTStyle style = mock(VTStyle.class);
		final VTStyleSelector styleSelector = mock(VTStyleSelector.class);
		when(style.getSelector()).thenReturn(styleSelector);

		when(styleSelector.isApplicable(isNull(VElement.class), isNull(ViewModelContext.class))).thenReturn(
			VTStyleSelector.NOT_APPLICABLE);
		when(styleSelector.isApplicable(isNull(VElement.class), notNull(ViewModelContext.class))).thenReturn(
			VTStyleSelector.NOT_APPLICABLE);
		when(styleSelector.isApplicable(notNull(VElement.class), isNull(ViewModelContext.class))).thenReturn(
			VTStyleSelector.NOT_APPLICABLE);
		when(styleSelector.isApplicable(notNull(VElement.class), notNull(ViewModelContext.class))).thenReturn(
			specificity);

		final VTStyleProperty styleProperty = mock(VTStyleProperty.class);
		final EList<VTStyleProperty> properties = new BasicEList<VTStyleProperty>();
		properties.add(styleProperty);

		when(style.getProperties()).thenReturn(properties);

		return style;
	}

	private static List<VTViewTemplate> createListWithTwoTemplates() {
		final VTViewTemplate viewTemplate1 = mock(VTViewTemplate.class);
		final EList<VTStyle> styles1 = new BasicEList<VTStyle>();
		when(viewTemplate1.getStyles()).thenReturn(styles1);
		final VTViewTemplate viewTemplate2 = mock(VTViewTemplate.class);
		final EList<VTStyle> styles2 = new BasicEList<VTStyle>();
		when(viewTemplate2.getStyles()).thenReturn(styles2);

		final ArrayList<VTViewTemplate> list = new ArrayList<VTViewTemplate>();
		list.add(viewTemplate1);
		list.add(viewTemplate2);
		return list;
	}
}