resource-registry/src/test/java/org/gcube/informationsystem/resourceregistry/instances/multicontext/MultiContextTest.java

package org.gcube.informationsystem.resourceregistry.instances.multicontext;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.UUID;

import org.gcube.com.fasterxml.jackson.databind.JsonNode;
import org.gcube.informationsystem.base.reference.Element;
import org.gcube.informationsystem.context.reference.entities.Context;
import org.gcube.informationsystem.model.reference.entities.Entity;
import org.gcube.informationsystem.model.reference.entities.Facet;
import org.gcube.informationsystem.model.reference.entities.Resource;
import org.gcube.informationsystem.model.reference.properties.PropagationConstraint.AddConstraint;
import org.gcube.informationsystem.model.reference.properties.PropagationConstraint.RemoveConstraint;
import org.gcube.informationsystem.model.reference.relations.ConsistsOf;
import org.gcube.informationsystem.model.reference.relations.IsRelatedTo;
import org.gcube.informationsystem.model.reference.relations.Relation;
import org.gcube.informationsystem.resourceregistry.ContextTest;
import org.gcube.informationsystem.resourceregistry.api.contexts.ContextCacheRenewal;
import org.gcube.informationsystem.resourceregistry.api.exceptions.ResourceRegistryException;
import org.gcube.informationsystem.resourceregistry.contexts.ContextUtility;
import org.gcube.informationsystem.resourceregistry.contexts.entities.ContextManagement;
import org.gcube.informationsystem.resourceregistry.instances.model.entities.ResourceManagement;
import org.gcube.informationsystem.types.TypeMapper;
import org.gcube.informationsystem.utils.ElementMapper;
import org.gcube.resourcemanagement.model.reference.entities.resources.EService;
import org.junit.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.orientechnologies.orient.core.record.ODirection;

public class MultiContextTest extends ContextTest {

	private static Logger logger = LoggerFactory.getLogger(MultiContextTest.class);

	private Map<UUID, Element> getRemovedExpectedInstances(Resource r) {
		Map<UUID, Element> expected = new HashMap<>();
		expected.put(r.getHeader().getUUID(), r);
		// TODO query

		for (IsRelatedTo<? extends Resource, ? extends Resource> isRelatedTo : r.getIsRelatedTo()) {
			// TODO
			if (isRelatedTo.getPropagationConstraint().getRemoveConstraint() == RemoveConstraint.cascade) {
				expected.put(isRelatedTo.getHeader().getUUID(), isRelatedTo);
				expected.putAll(getRemovedExpectedInstances(isRelatedTo.getTarget()));

				// TODO
			}

			if (isRelatedTo.getPropagationConstraint().getRemoveConstraint() == RemoveConstraint.cascadeWhenOrphan) {
				expected.put(isRelatedTo.getHeader().getUUID(), isRelatedTo);
				expected.putAll(getRemovedExpectedInstances(isRelatedTo.getTarget()));

				// TODO

				// TODO
			}
		}
		for (ConsistsOf<? extends Resource, ? extends Facet> consistsOf : r.getConsistsOf()) {
			if (consistsOf.getPropagationConstraint().getRemoveConstraint() == RemoveConstraint.cascade || consistsOf
					.getPropagationConstraint().getRemoveConstraint() == RemoveConstraint.cascadeWhenOrphan) {
				expected.put(consistsOf.getHeader().getUUID(), consistsOf);
				Facet facet = consistsOf.getTarget();
				expected.put(facet.getHeader().getUUID(), facet);
			}
		}
		return expected;
	}

	@SuppressWarnings("unused")
	private void removeFromContextThenTestIfBehaveProperly(Resource r, boolean dryRun)
			throws ResourceRegistryException {
		Map<UUID, Element> expectedInstances = getRemovedExpectedInstances(r);

		ResourceManagement resourceManagement = new ResourceManagement();
		resourceManagement.setElementType(TypeMapper.getType(r.getClass()));
		resourceManagement.setUUID(r.getHeader().getUUID());
		resourceManagement.setDryRun(dryRun);
		UUID contextUUID = ContextUtility.getCurrentSecurityContext().getUUID();
		Map<UUID, JsonNode> affectedInstances = resourceManagement.removeFromContext(contextUUID);

		SortedSet<UUID> expectedInstancesUUID = new TreeSet<>(expectedInstances.keySet());
		SortedSet<UUID> affectedInstancesUUID = new TreeSet<>(affectedInstances.keySet());

		logger.trace("Expected Instances are {} : {}", expectedInstancesUUID.size(), expectedInstancesUUID);
		logger.trace("Affected Instances are {} : {}", affectedInstancesUUID.size(), affectedInstancesUUID);

		Assert.assertTrue(expectedInstancesUUID.size() == affectedInstancesUUID.size());

		Assert.assertTrue(expectedInstancesUUID.containsAll(affectedInstancesUUID));
		Assert.assertTrue(affectedInstancesUUID.containsAll(expectedInstancesUUID));

		for (UUID uuid : affectedInstances.keySet()) {

			Element element = expectedInstances.get(uuid);
			String expectedType = TypeMapper.getType(element.getClass());

			JsonNode affectedJsonNode = affectedInstances.get(uuid);
			String affectedType = affectedJsonNode.get(Element.CLASS_PROPERTY).asText();

			Assert.assertTrue(affectedType.compareTo(expectedType) == 0);

		}

	}

	private interface RelationConstraint {

		public boolean mustBeAdded(Relation<Resource, Entity> r);

		public boolean mustBeRemoved(Relation<Resource, Entity> r);

	}

	protected Resource getAndAddIsRelatedTo(Resource r, RelationConstraint relationConstraint)
			throws ResourceRegistryException, Exception {
		ResourceManagement resourceManagement = new ResourceManagement();
		resourceManagement.setElementType(Resource.NAME);

		String resourceType = TypeMapper.getType(r);
		UUID resourceUUID = r.getHeader().getUUID();

		// resourceManagement.setUUID(resourceUUID);
		String ret = resourceManagement.query(IsRelatedTo.NAME, resourceType, resourceUUID, ODirection.IN, true,
				new HashMap<>(), true);
		@SuppressWarnings("rawtypes")
		List<IsRelatedTo> isRelatedToList = ElementMapper.unmarshalList(IsRelatedTo.class, ret);
		for (@SuppressWarnings("rawtypes")
		IsRelatedTo isRelatedTo : isRelatedToList) {
			@SuppressWarnings("unchecked")
			boolean mustBeAdded = relationConstraint.mustBeAdded(isRelatedTo);
			if (mustBeAdded) {
				@SuppressWarnings("unchecked")
				IsRelatedTo<EService, Resource> irt = (IsRelatedTo<EService, Resource>) isRelatedTo;
				r.attachResource(irt);
			}
		}
		return r;
	}

	protected Map<UUID, Element> getAddedExpectedInstances(Resource r) throws ResourceRegistryException, Exception {
		Map<UUID, Element> expected = new HashMap<>();
		expected.put(r.getHeader().getUUID(), r);

		RelationConstraint propagateConstraint = new RelationConstraint() {

			@Override
			public boolean mustBeAdded(Relation<Resource, Entity> r) {
				return r.getPropagationConstraint().getAddConstraint() == AddConstraint.propagate;
			}

			@Override
			public boolean mustBeRemoved(Relation<Resource, Entity> r) {
				throw new UnsupportedOperationException();
			}

		};

		r = getAndAddIsRelatedTo(r, propagateConstraint);

		for (IsRelatedTo<? extends Resource, ? extends Resource> isRelatedTo : r.getIsRelatedTo()) {
			if (isRelatedTo.getPropagationConstraint().getAddConstraint() == AddConstraint.propagate) {
				expected.put(isRelatedTo.getHeader().getUUID(), isRelatedTo);
				expected.putAll(getAddedExpectedInstances(isRelatedTo.getTarget()));
			}
		}
		for (ConsistsOf<? extends Resource, ? extends Facet> consistsOf : r.getConsistsOf()) {
			if (consistsOf.getPropagationConstraint().getAddConstraint() == AddConstraint.propagate) {
				expected.put(consistsOf.getHeader().getUUID(), consistsOf);
				Facet facet = consistsOf.getTarget();
				expected.put(facet.getHeader().getUUID(), facet);
			}
		}
		return expected;
	}

	protected void addToContextThenTestIfBehaveProperly(Resource r, boolean dryRun, String targetContextFullName)
			throws ResourceRegistryException, Exception {

		Map<UUID, Element> expectedInstances = getAddedExpectedInstances(r);

		ResourceManagement resourceManagement = new ResourceManagement();
		resourceManagement.setElementType(TypeMapper.getType(r));
		resourceManagement.setUUID(r.getHeader().getUUID());
		resourceManagement.setDryRun(dryRun);
		UUID contextUUID = ContextUtility.getInstance().getSecurityContextByFullName(targetContextFullName).getUUID();
		Map<UUID, JsonNode> affectedInstances = resourceManagement.addToContext(contextUUID);

		SortedSet<UUID> expectedInstancesUUID = new TreeSet<>(expectedInstances.keySet());
		SortedSet<UUID> affectedInstancesUUID = new TreeSet<>(affectedInstances.keySet());

		logger.trace("Expected Instances are {} : {}", expectedInstancesUUID.size(), expectedInstancesUUID);
		logger.trace("Affected Instances are {} : {}", affectedInstancesUUID.size(), affectedInstancesUUID);

		Assert.assertTrue(expectedInstancesUUID.size() == affectedInstancesUUID.size());

		Assert.assertTrue(expectedInstancesUUID.containsAll(affectedInstancesUUID));
		Assert.assertTrue(affectedInstancesUUID.containsAll(expectedInstancesUUID));

		for (UUID uuid : affectedInstances.keySet()) {

			Element element = expectedInstances.get(uuid);
			String expectedType = TypeMapper.getType(element.getClass());

			JsonNode affectedJsonNode = affectedInstances.get(uuid);
			String affectedType = affectedJsonNode.get(Element.CLASS_PROPERTY).asText();

			Assert.assertTrue(affectedType.compareTo(expectedType) == 0);

		}

	}

	protected ContextCacheRenewal contextCacheRenewal = new ContextCacheRenewal() {

		@Override
		public List<Context> renew() throws ResourceRegistryException {
			ContextManagement contextManagement = new ContextManagement();
			String contextsJsonString = contextManagement.allFromServer(false);
			List<Context> contexts = null;
			try {
				contexts = ElementMapper.unmarshalList(contextsJsonString);
			} catch (IOException e) {
				logger.error("Unable to read context from server", e);
			}
			return contexts;
		}
	};

}