DynamicMapTest.java

package org.emfjson.jackson.tests.dynamic;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.eclipse.emf.common.util.BasicEMap;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.impl.DynamicEObjectImpl.BasicEMapEntry;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.emfjson.jackson.module.EMFModule;
import org.emfjson.jackson.resource.JsonResourceFactory;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.nio.file.Paths;
import java.util.Collection;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

public class DynamicMapTest {

	private ObjectMapper mapper = new ObjectMapper();

	private EClass eTypesClass, typeClass, valueClass, tmapClass, stringMapClass;
	private ResourceSetImpl resourceSet;

	@Before
	public void setUp() {
		URI modelURI = URI.createURI("http://www.emfjson.org/jackson/model");

		mapper.registerModule(new EMFModule());

		resourceSet = new ResourceSetImpl();

		resourceSet.getResourceFactoryRegistry()
				.getExtensionToFactoryMap()
				.put("*", new JsonResourceFactory(mapper));

		resourceSet.getPackageRegistry()
				.put(EcorePackage.eNS_URI, EcorePackage.eINSTANCE);

		resourceSet.getURIConverter()
				.getURIMap()
				.put(modelURI, URI.createURI("src/test/resources/model/dynamic/model-2.json"));

		final Resource resource = resourceSet.getResource(modelURI, true);
		final EPackage ePackage = (EPackage) resource.getContents().get(0);

		resourceSet.getPackageRegistry().put(ePackage.getNsURI(), ePackage);

		eTypesClass = (EClass) ePackage.getEClassifier("ETypes");
		tmapClass = (EClass) ePackage.getEClassifier("TMap");
		stringMapClass = (EClass) ePackage.getEClassifier("StringMap");
		typeClass = (EClass) ePackage.getEClassifier("Type");
		valueClass = (EClass) ePackage.getEClassifier("Value");
	}

	@Test
	@SuppressWarnings("unchecked")
	public void testSaveMap() throws IOException {
		JsonNode expected = mapper.readTree(
				Paths.get("src/test/resources/tests/test-map-1.json").toFile());

		Resource resource = resourceSet.createResource(URI.createURI("test"));

		EObject a1 = EcoreUtil.create(eTypesClass);
		Collection values = (Collection) a1.eGet(eTypesClass.getEStructuralFeature("values"));

		{
			EObject key = EcoreUtil.create(typeClass);
			key.eSet(typeClass.getEStructuralFeature("name"), "t1");

			EObject value = EcoreUtil.create(valueClass);
			value.eSet(valueClass.getEStructuralFeature("value"), 1);

			BasicEMapEntry<EObject, EObject> entry = new BasicEMapEntry<>();
			entry.eSetClass(tmapClass);
			entry.setKey(key);
			entry.setValue(value);

			values.add(entry);
		}

		{
			EObject key = EcoreUtil.create(typeClass);
			key.eSet(typeClass.getEStructuralFeature("name"), "t2");

			EObject value = EcoreUtil.create(valueClass);
			value.eSet(valueClass.getEStructuralFeature("value"), 2);

			BasicEMapEntry<EObject, EObject> entry = new BasicEMapEntry<>();
			entry.eSetClass(tmapClass);
			entry.setKey(key);
			entry.setValue(value);

			values.add(entry);
		}

		resource.getContents().add(a1);

		assertThat(mapper.valueToTree(resource)).
				isEqualTo(expected);
	}

	@Test
	public void testLoadMap() {
		Resource resource = resourceSet.getResource(
				URI.createURI("src/test/resources/tests/test-map-1.json"), true);

		assertThat(resource.getContents()).hasSize(1);
		assertThat(resource.getContents().get(0).eClass())
				.isSameAs(eTypesClass);

		EObject types = resource.getContents().get(0);

		assertThat((Collection) types.eGet(eTypesClass.getEStructuralFeature("values")))
				.hasSize(2);
	}

	@Test
	@SuppressWarnings("unchecked")
	public void testSaveMapWithStringKey() throws IOException {
		JsonNode expected = mapper.readTree(
				Paths.get("src/test/resources/tests/test-map-2.json").toFile());

		Resource resource = resourceSet.createResource(URI.createURI("test"));

		EObject a1 = EcoreUtil.create(eTypesClass);
		Collection values = (Collection) a1.eGet(eTypesClass.getEStructuralFeature("stringMapValues"));

		EObject v1 = EcoreUtil.create(valueClass);
		v1.eSet(valueClass.getEStructuralFeature("value"), 1);

		EObject v2 = EcoreUtil.create(valueClass);
		v2.eSet(valueClass.getEStructuralFeature("value"), 2);

		BasicEMapEntry<EObject, EObject> e1 = new BasicEMapEntry<>();
		e1.eSetClass(stringMapClass);
		e1.setKey("Hello");
		e1.setValue(v1);

		BasicEMapEntry<EObject, EObject> e2 = new BasicEMapEntry<>();
		e2.eSetClass(stringMapClass);
		e2.setKey("World");
		e2.setValue(v2);

		values.add(e1);
		values.add(e2);

		resource.getContents().add(a1);

		assertThat(mapper.valueToTree(resource)).
				isEqualTo(expected);
	}

	@Test
	@SuppressWarnings("unchecked")
	public void testLoadMapWithStringKey() {
		Resource resource = resourceSet.getResource(URI.createURI("src/test/resources/tests/test-map-2.json"), true);

		assertThat(resource.getContents()).hasSize(1);
		assertThat(resource.getContents().get(0).eClass())
				.isSameAs(eTypesClass);

		EObject types = resource.getContents().get(0);

		List<BasicEMap.Entry<String, EObject>> mapValues = (List<BasicEMap.Entry<String, EObject>>)
				types.eGet(eTypesClass.getEStructuralFeature("stringMapValues"));

		assertThat(mapValues)
				.hasSize(2);

		assertThat(mapValues.get(0).getKey()).isEqualTo("Hello");
		assertThat(1)
				.isEqualTo(valueOf(mapValues.get(0).getValue()));

		assertThat(mapValues.get(1).getKey()).isEqualTo("World");
		assertThat(2)
				.isEqualTo(valueOf(mapValues.get(1).getValue()));
	}

	private int valueOf(EObject value) {
		return (int) value.eGet(valueClass.getEStructuralFeature("value"));
	}

}