D-Net

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import java.io.InputStream;

import java.util.List;

import com.fasterxml.jackson.core.JsonFactory;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMdig;

import eu.dnetlib.parthenos.CRMpe;

import eu.dnetlib.parthenos.jrr.ParthenosRegistryRel;

import eu.dnetlib.parthenos.jrr.ParthenosRegistryResource;

import eu.dnetlib.parthenos.publisher.ParthenosPublisherException;

import eu.dnetlib.parthenos.rdf.ResourceReader;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.jena.ontology.OntModel;

import org.apache.jena.ontology.OntModelSpec;

import org.apache.jena.rdf.model.*;

import org.apache.jena.vocabulary.RDF;

import org.gcube.informationsystem.resourceregistry.api.exceptions.ResourceRegistryException;

import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClient;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.mockito.Mock;

import org.mockito.Mockito;

import org.springframework.boot.test.mock.mockito.MockBean;

import org.springframework.core.io.ClassPathResource;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

/**

 * Created by Alessia Bardi on 28/09/2017.

 *

 * //TODO: Avoid loading remote resources (see setup())

 *

 * @author Alessia Bardi

 */

@Ignore

public class GCubeResourceRegistratorTest {

	private String nakalaService = "eu/dnetlib/parthenos/registry/nakala.rdf";

	private String test = "eu/dnetlib/parthenos/registry/test.rdf";

	private GCubeResourceRegistrator reg;

	private OntModel baseModel;

	private ResourceRegistryClient regClient = Mockito.mock(ResourceRegistryClient.class);

	@Before

	public void setup(){

		reg = new GCubeResourceRegistrator();

		FacetWriter facetWriter = new FacetWriter();

		facetWriter.setResourceReader(new ResourceReader());

		reg.setFacetWriter(facetWriter);

		reg.setResourceReader(new ResourceReader());

		baseModel = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM_TRANS_INF);

		baseModel.read(CRMpe.RDFS_URL);

		baseModel.read(CRM.RDFS_URL);

		baseModel.read(CRMdig.RDFS_URL);

		Mockito.when(regClient.query(Mockito.anyString(), Mockito.anyInt(), Mockito.anyString())).thenReturn(null);

		reg.setResourceRegistryClient(regClient);

	}

	@Test

	public void testProcessService() throws Exception{

		String resource = getString(nakalaService);

		InfModel model = loadBaseModel();

		model.read(IOUtils.toInputStream(resource, "UTF-8"), CRMpe.NS);

		ResIterator subjects = model.listSubjectsWithProperty(RDF.type, CRM.E7_Activity);

		while (subjects.hasNext()) {

			Resource subject = subjects.nextResource();

			ParthenosRegistryResource prr = reg.processService(subject, new JsonFactory(), "FAKEUUID");

			System.out.println(prr.getJson());

			final List<ParthenosRegistryRel> resourceRels = reg.getResourceRels(subject, prr);

			for(ParthenosRegistryRel r : resourceRels){

				System.out.println(r.getJson());

			}

		}

	}

	@Test

	public void testLoadBaseModel() {

		//let's snapshot to a normal model to write all statements

		Model snapshot = ModelFactory.createDefaultModel();

		snapshot.add(baseModel);

	}

	@Test

	public void testLoadRDFFileWithModel() throws IOException {

		//let's snapshot to a normal model to write all statements

		Model snapshot = ModelFactory.createDefaultModel();

		snapshot.add(baseModel);

		snapshot.write(System.out);

	}

	@Test

	public void testRules() throws IOException {

		StmtIterator it = baseModel.listStatements(new SimpleSelector(ResourceFactory.createResource("uuid:AAAH"), RDF.type, (Resource) null));

		while(it.hasNext()){

			System.out.println(it.nextStatement().toString());

		}

		Resource classHS = ResourceFactory.createResource(CRMpe.NS+"PE1_Service");

		StmtIterator it2 = baseModel.listStatements(classHS, RDF.type, (Resource) null);

		while(it2.hasNext()){

			System.out.println(it2.nextStatement().toString());

		}

	}

	@Test

	public void testAmbiguousSpecificType() throws IOException {

		Resource res = baseModel.getResource("uuid:AAAH");

		Resource specificType = reg.getResourceReader().findSpecificType(res, CRMpe.PE1_Service);

		System.out.println(specificType.getURI());

		assertEquals(CRMpe.PE1_Service.getURI(), specificType.getURI());

	}

	@Test

	public void testDashes() throws IOException {

		System.out.println(StringUtils.remove(CRMpe.NS+"PE1_Service-HOLA", "-"));

	}

	@Test

	public void testJsonGeneration1() throws IOException, ResourceRegistryException, ParthenosPublisherException {

		testJsonGeneration(test);

	}

	@Test

	public void testJsonGeneration2() throws IOException, ResourceRegistryException, ParthenosPublisherException {

		//testJsonGeneration(recordPath);

	}

	@Test

	public void testJsonGeneration3() throws IOException, ResourceRegistryException, ParthenosPublisherException {

		testJsonGeneration(nakalaService);

	}

	private void testJsonGeneration(final String recordClasspath) throws IOException, ResourceRegistryException,

			ParthenosPublisherException {

		try {

			//reg.register(getString(recordClasspath), objIdentifier);

		}catch(NullPointerException npe){

			//ok: it is because of the registryPublisher

		}

	}

	private String getString(final String classpath) {

		try {

			final ClassPathResource resource = new ClassPathResource(classpath);

			return IOUtils.toString(resource.getInputStream(), "UTF-8");

		}catch(IOException e){

			return null;

		}

	}

	private static InputStream getStream(final String classpath) throws IOException {

		return new ClassPathResource(classpath).getInputStream();

	}

	protected InfModel loadBaseModel() {

		return ModelFactory.createRDFSModel(baseModel);

	}

}