D-Net

package eu.dnetlib.data.actionmanager.actions;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.xml.transform.TransformerException;

import eu.dnetlib.data.proto.DNGFProtos.DNGF;

import eu.dnetlib.rmi.data.hadoop.actionmanager.ActionManagerException;

import eu.dnetlib.rmi.data.hadoop.actionmanager.Agent;

import eu.dnetlib.rmi.data.hadoop.actionmanager.Operation;

import eu.dnetlib.rmi.data.hadoop.actionmanager.Provenance;

import eu.dnetlib.rmi.data.hadoop.actionmanager.actions.ActionFactory;

import eu.dnetlib.rmi.data.hadoop.actionmanager.actions.AtomicAction;

import eu.dnetlib.rmi.data.hadoop.actionmanager.actions.XsltInfoPackageAction;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.io.SAXReader;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.Mockito;

import org.mockito.runners.MockitoJUnitRunner;

import org.springframework.core.io.Resource;

import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)

public class ActionFactoryTest {

	private static final Log log = LogFactory.getLog(ActionFactoryTest.class);

	private static String basePathProfiles = "/eu/dnetlib/bootstrap/profiles/TransformationRuleDSResources/TransformationRuleDSResourceType/";

	private final static Agent agent = new Agent("agentId", "agentName", Agent.AGENT_TYPE.algo);

	private final static String trust = "0.9";

	private final InputStream recordOdfInputStream = getClass().getResourceAsStream("recordOdf.xml");

	private final InputStream recordOafInputStream = getClass().getResourceAsStream("recordOaf.xml");

	private ActionFactory actionFactory;

	private Map<String, Resource> xslts = new HashMap<>();

	@Mock

	private Resource oaf2insertActions;

	@Mock

	private Resource oaf2updateActions;

	@Mock

	private Resource odf2insertActions;

	@Mock

	private Resource odf2updateActions;

	@Mock

	private Resource rels2actions;

	@Before

	public void setUp() throws Exception {

		actionFactory = new ActionFactory();

		xslts.put("oaf2insertActions", oaf2insertActions);

		xslts.put("oaf2updateActions", oaf2updateActions);

		xslts.put("odf2insertActions", odf2insertActions);

		xslts.put("odf2updateActions", odf2updateActions);

		xslts.put("rels2actions", rels2actions);

		Mockito.when(oaf2insertActions.getInputStream()).thenReturn(loadFromTransformationProfile("oaf2insertActions.xml"));

		Mockito.when(oaf2updateActions.getInputStream()).thenReturn(loadFromTransformationProfile("oaf2updateActions.xml"));

		Mockito.when(odf2insertActions.getInputStream()).thenReturn(loadFromTransformationProfile("odf2insertActions.xml"));

		Mockito.when(odf2updateActions.getInputStream()).thenReturn(loadFromTransformationProfile("odf2updateActions.xml"));

//		Mockito.when(rels2actions.getInputStream()).thenReturn(loadFromTransformationProfile("rels2actions.xml"));

		actionFactory.setXslts(xslts);

	}

	@Test

	public void testBeans() {

		assertNotNull(actionFactory);

		assertNotNull(actionFactory.getXslts());

		assertFalse(actionFactory.getXslts().isEmpty());

	}

	@Test

	public void testDataciteInsert() throws ActionManagerException, IOException, TransformerException, DocumentException {

		XsltInfoPackageAction action =

				actionFactory.generateInfoPackageAction("odf2insertActions", "rawSet", agent, Operation.INSERT, asString(recordOdfInputStream),

						Provenance.sysimport_crosswalk_datasetarchive, "datacite____", trust);

		checkActions(action, action.asAtomicActions());

	}

	@Test

	public void testDataciteUpdate() throws ActionManagerException, IOException, TransformerException, DocumentException {

		XsltInfoPackageAction action =

				actionFactory.generateInfoPackageAction("odf2updateActions", "rawSet", agent, Operation.UPDATE, asString(recordOdfInputStream),

						Provenance.sysimport_crosswalk_datasetarchive, "datacite____", trust);

		checkActions(action, action.asAtomicActions());

	}

	@Test

	public void testRecordOafInsert() throws ActionManagerException, IOException, TransformerException, DocumentException {

		XsltInfoPackageAction action =

				actionFactory.generateInfoPackageAction("oaf2insertActions", "rawSet", agent, Operation.INSERT, asString(recordOafInputStream),

						Provenance.sysimport_crosswalk_datasetarchive, "od_______296", trust);

		checkActions(action, action.asAtomicActions());

	}

	@Test

	public void testRecordOafUpdate() throws ActionManagerException, IOException, TransformerException, DocumentException {

		XsltInfoPackageAction action =

				actionFactory.generateInfoPackageAction("oaf2updateActions", "rawSet", agent, Operation.INSERT, asString(recordOafInputStream),

						Provenance.sysimport_crosswalk_datasetarchive, "od_______296", trust);

		checkActions(action, action.asAtomicActions());

	}

	private void checkActions(final XsltInfoPackageAction action, final List<AtomicAction> atomicActionList)

			throws TransformerException, DocumentException, com.google.protobuf.InvalidProtocolBufferException {

		for (AtomicAction a : action.calculateAtomicActions()) {

			assertNotNull(a.getTargetValue());

			String actionJSON = AtomicActionSerialiser.toJSON(a);

			log.info(actionJSON);

			final AtomicAction aa = AtomicActionDeserialiser.fromJSON(actionJSON);

			assertEquals(a.getRawSet(), aa.getRawSet());

			assertEquals(a.getTargetColumn(), aa.getTargetColumn());

			assertEquals(a.getTargetColumnFamily(), aa.getTargetColumnFamily());

			assertEquals(a.getTargetRowKey(), aa.getTargetRowKey());

			assertEquals(a.getActionType(), aa.getActionType());

			assertEquals(a.getRowKey(), aa.getRowKey());

			assertEquals(a.getAgent().getId(), aa.getAgent().getId());

			assertEquals(a.getAgent().getName(), aa.getAgent().getName());

			assertEquals(a.getAgent().getType(), aa.getAgent().getType());

			assertTrue(Arrays.equals(a.getTargetValue(), aa.getTargetValue()));

			System.out.println(DNGF.parseFrom(aa.getTargetValue()));

		}

		for (AtomicAction aa : atomicActionList) {

			assertNotNull(aa);

		}

		log.info("N. puts: " + atomicActionList.size());

	}

	private String asString(final InputStream i) throws IOException {

		StringWriter writer = new StringWriter();

		IOUtils.copy(i, writer);

		return writer.toString();

	}

	private InputStream loadFromTransformationProfile(final String profilePath) {

		log.info("Loading xslt from: " + basePathProfiles + profilePath);

		InputStream profile = getClass().getResourceAsStream(basePathProfiles + profilePath);

		final String s;

		try {

			s = IOUtils.toString(profile);

			log.debug("profile: " + s);

		} catch (IOException e) {

			e.printStackTrace();

			throw new RuntimeException(e);

		}

		final SAXReader saxReader = new SAXReader();

		Document doc = null;

		try {

			doc = saxReader.read(new StringReader(s));

		} catch (DocumentException e) {

			e.printStackTrace();

			throw new RuntimeException(e);

		}

		String xslt = doc.selectSingleNode("//SCRIPT/CODE/*[local-name()='stylesheet']").asXML();

		return IOUtils.toInputStream(xslt);

	}

}