D-Net

package eu.dnetlib.parthenos.virtuoso;

import java.io.IOException;

import java.io.InputStream;

import java.util.List;

import org.apache.commons.io.IOUtils;

import org.apache.http.HttpEntity;

import org.apache.http.NameValuePair;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.util.EntityUtils;

import org.apache.jena.graph.NodeFactory;

import org.apache.jena.graph.Triple;

import org.apache.jena.query.Query;

import org.apache.jena.query.QueryExecutionFactory;

import org.apache.jena.query.QueryFactory;

import org.apache.jena.query.ResultSet;

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

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

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

import org.apache.jena.riot.RDFDataMgr;

import org.apache.jena.riot.RDFFormat;

import org.apache.jena.sparql.engine.http.QueryEngineHTTP;

import org.apache.jena.sparql.engine.http.QueryExceptionHTTP;

import org.apache.jena.util.iterator.ExtendedIterator;

import org.assertj.core.util.Lists;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.JUnit4;

import org.springframework.core.io.ClassPathResource;

import virtuoso.jena.driver.VirtGraph;

import virtuoso.jena.driver.VirtModel;

import virtuoso.jena.driver.VirtuosoQueryExecution;

import virtuoso.jena.driver.VirtuosoQueryExecutionFactory;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

/**

 * Created by Alessia Bardi on 11/07/2017.

 *

 * @author Alessia Bardi

 */

@Ignore

@RunWith(JUnit4.class)

public class VirtuosoTest {

	private String testGraph = "virt:test";

	private String connectionString = "jdbc:virtuoso://localhost:1111";

	private String testUser = "dba";

	private String testPwd = "dba";

	private String defaultURIBaseURl = "http://test/";

	private String sparqlEndpoint = "http://localhost:8890/sparql";

	@Before

	public void prepare() {

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

		graph.clear();

	}

	/**

	 * See also: https://stackoverflow.com/questions/24576190/enable-reasoning-for-sparql-request-via-jena

	 */

	@Test

	public void testInference1() {

		String q = "DEFINE input:inference 'parthenos_rules' CONSTRUCT {<%s> ?p ?o . } WHERE { <%s> ?p ?o .}";

		String subjectURL = "http://clarin.eu/clarin-eric-datatables/centres";

		String query = String.format(q, subjectURL, subjectURL, subjectURL, subjectURL);

		System.out.println(query);

		final QueryEngineHTTP request = new QueryEngineHTTP(sparqlEndpoint, query);

		Model res = request.execConstruct();

		RDFDataMgr.write(System.out, res, RDFFormat.RDFXML_PLAIN);

		res.close();

		request.close();

	}

	@Test

	public void testLongQuery() throws IOException {

		String q = IOUtils.toString(getResourceAsStream("/eu/dnetlib/parthenos/sparql/longQuery.sparql"));

		try (CloseableHttpClient httpclient = HttpClients.createDefault()) {

			HttpPost httpPost = new HttpPost(sparqlEndpoint);

			List<NameValuePair> nvps = Lists.newArrayList();

			nvps.add(new BasicNameValuePair("query", q));

			httpPost.setEntity(new UrlEncodedFormEntity(nvps));

			try (CloseableHttpResponse response2 = httpclient.execute(httpPost)) {

				System.out.println(response2.getStatusLine());

				HttpEntity entity2 = response2.getEntity();

				String s = IOUtils.toString(entity2.getContent());

				System.out.println("OUT: " + s);

				// do something useful with the response body

				// and ensure it is fully consumed

				EntityUtils.consume(entity2);

			}

		}

	}

	@Test(expected = QueryExceptionHTTP.class)

	public void testLongQueryFails() throws IOException {

		String q = IOUtils.toString(getResourceAsStream("/eu/dnetlib/parthenos/sparql/longQuery.sparql"));

		final QueryEngineHTTP request = new QueryEngineHTTP(sparqlEndpoint, q);

		Model res = request.execConstruct();

		RDFDataMgr.write(System.out, res, RDFFormat.RDFXML_PLAIN);

		res.close();

		request.close();

	}

	@Test

	public void testRemote() {

		String q = "DEFINE input:inference 'parthenos_rules' CONSTRUCT {<%s> ?p ?o . } WHERE { <%s> ?p ?o .}";

		//String q = "CONSTRUCT {<%s> ?p ?o . } WHERE { <%s> ?p ?o .}";

		String subjectURL = "http://clarin.eu/clarin-eric-datatables/centres";

		String query = String.format(q, subjectURL, subjectURL, subjectURL, subjectURL);

		System.out.println(query);

		VirtGraph g = new VirtGraph(connectionString, testUser, testPwd);

		g.setReadFromAllGraphs(true);

		VirtuosoQueryExecution vqe = VirtuosoQueryExecutionFactory.create(query, g);

		Model resultModel = vqe.execConstruct();

		RDFDataMgr.write(System.out, resultModel, RDFFormat.RDFXML_PLAIN);

		vqe.close();

		g.close();

	}

	@Test

	public void testConnection() {

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

	}

	@Test

	public void testDescribe() {

		//put something in the graph

		Model md = VirtModel.openDatabaseModel(testGraph, connectionString, testUser, testPwd);

		md.read(getResourceAsStream("eu/dnetlib/parthenos/virtuoso/test.rdf"), defaultURIBaseURl);

		String resURI = "http://www.parthenos-project.eu/ARIADNE/ARIADNECatalog/Dataset/http%3A%2F%2Fregistry.ariadne-infrastructure.eu%2Fdataset%2F25058478";

		//now query for the resource URI

		String describeQuery = "DESCRIBE <" + resURI + ">";

		Query query = QueryFactory.create(describeQuery);

		String sparqlUrl = "http://localhost:8890/sparql";

		final QueryEngineHTTP serviceRequest = QueryExecutionFactory.createServiceRequest(sparqlUrl, query);

		Model resultModel = serviceRequest.execDescribe();

		serviceRequest.close();

		resultModel.write(System.out);

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		graph.clear();

	}

	@Ignore

	@Test

	public void testDescribeRemote() {

		String resURI = "http://hdl.handle.net/11858/00-203C-0000-0029-F5E8-C";

		//now query for the resource URI

		String describeQuery = "DESCRIBE <" + resURI + ">";

		Query query = QueryFactory.create(describeQuery);

		String sparqlUrl = "https://virtuoso.parthenos.d4science.org/sparql";

		final QueryEngineHTTP serviceRequest = QueryExecutionFactory.createServiceRequest(sparqlUrl, query);

		Model resultModel = serviceRequest.execDescribe();

		serviceRequest.close();

		resultModel.write(System.out);

	}

	@Test

	public void testReadForDescribeResource() {

		String sparqlUrl = "http://localhost:8890/sparql";

		String queryForGraphs =

				"SELECT DISTINCT ?g \n"

						+ "WHERE {\n"

						+ "  { ?g <dnetcollectedFrom> <http://parthenos.d4science.org/handle/api_________::parthenos___::clarin::p_1271859438164> }\n"

						+ "}";

		Query query = QueryFactory.create(queryForGraphs);

		final QueryEngineHTTP serviceRequest = QueryExecutionFactory.createServiceRequest(sparqlUrl, query);

		ResultSet graphs = serviceRequest.execSelect();

		String queryForSubjectsTemplate = "SELECT DISTINCT ?s WHERE {GRAPH <%s> {?s ?p ?o}}";

		int countGraphs = 0;

		while (graphs.hasNext()) {

			countGraphs++;

			Resource g = graphs.next().getResource("g");

			System.out.println("*****GRAPH: " + g.getURI());

			final QueryEngineHTTP serviceRequest2 =

					QueryExecutionFactory.createServiceRequest(sparqlUrl, QueryFactory.create(String.format(queryForSubjectsTemplate, g.getURI())));

			ResultSet subjects = serviceRequest2.execSelect();

			int countSubjects = 0;

			while (subjects.hasNext()) {

				countSubjects++;

				Resource s = subjects.next().getResource("s");

				String describeQuery = "DESCRIBE <" + s.getURI() + ">";

				final QueryEngineHTTP serviceRequest3 = QueryExecutionFactory.createServiceRequest(sparqlUrl, QueryFactory.create(describeQuery));

				Model resultModel = serviceRequest3.execDescribe();

				serviceRequest3.close();

				resultModel.write(System.out);

			}

			serviceRequest2.close();

			System.out.println("Got " + countSubjects + " subjects");

		}

		serviceRequest.close();

		assertEquals("unexpected number of graphs", 4, countGraphs);

	}

	@Test

	public void testClear() {

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

		graph.clear();

		Assert.assertTrue(graph.isEmpty());

	}

	@Test

	public void testFeedTriple() {

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

		graph.clear();

		Assert.assertTrue(graph.isEmpty());

		Triple t = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_friend_of"),

				NodeFactory.createURI("http://test/KevinBacon"));

		graph.performAdd(t);

		assertEquals(1, graph.getCount());

		graph.clear();

	}

	@Test

	public void testFeedRDFFile() {

		Model md = VirtModel.openDatabaseModel(testGraph, connectionString, testUser, testPwd);

		md.read(getResourceAsStream("eu/dnetlib/parthenos/virtuoso/test.rdf"), defaultURIBaseURl);

		long size = md.size();

		System.out.println("==Inserted " + size + "triples==");

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

		Assert.assertFalse(graph.isEmpty());

		graph.clear();

	}

	/*

	If we want to be able to update, we need to store the triples in different named graph. This way we can delete the old triples and add the new ones.

	And then we can add triples about the graph (e.g. provenance, last update time, whatever) in another named graph (e.g. 'provenance'),

	where all the info about the named graphs are available.

	 */

	@Test

	public void testUpdate() {

		String namedGraph = "virt:test:theObjIdentifier";

		Model md = VirtModel.openDatabaseModel(namedGraph, connectionString, testUser, testPwd);

		md.read(getResourceAsStream("eu/dnetlib/parthenos/virtuoso/test.rdf"), defaultURIBaseURl);

		long size = md.size();

		System.out.println("==Inserted " + size + "triples==");

		md.removeAll();

		Assert.assertTrue(md.isEmpty());

		md.read(getResourceAsStream("eu/dnetlib/parthenos/virtuoso/test_less_data.rdf"), defaultURIBaseURl);

		long size2 = md.size();

		System.out.println("==Inserted " + size2 + "triples==");

		md.removeAll();

	}

	@Test

	public void testRemoveAllWildcards() {

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

		graph.clear();

		Assert.assertTrue(graph.isEmpty());

		Triple t1 = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_friend_of"),

				NodeFactory.createURI("http://test/KevinBacon"));

		Triple t2 = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_friend_of"),

				NodeFactory.createURI("http://test/BonoVox"));

		Triple t3 = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_enemy_of"),

				NodeFactory.createURI("http://test/Spiderman"));

		graph.performAdd(t1);

		graph.performAdd(t2);

		graph.performAdd(t3);

		assertEquals(3, graph.getCount());

		Model md = VirtModel.openDatabaseModel(testGraph, connectionString, testUser, testPwd);

		assertEquals(3, md.size());

		md.removeAll(ResourceFactory.createResource("http://test/1"), ResourceFactory.createProperty("http://test/is_enemy_of"), null);

		assertEquals(2, md.size());

	}

	@Test

	public void testSearch() {

		VirtGraph graph = new VirtGraph(testGraph, connectionString, testUser, testPwd);

		assertNotNull(graph);

		graph.clear();

		Assert.assertTrue(graph.isEmpty());

		Triple t1 = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_friend_of"),

				NodeFactory.createURI("http://test/KevinBacon"));

		Triple t2 = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_friend_of"),

				NodeFactory.createURI("http://test/BonoVox"));

		Triple t3 = new Triple(NodeFactory.createURI("http://test/1"), NodeFactory.createURI("http://test/is_enemy_of"),

				NodeFactory.createURI("http://test/Spiderman"));

		graph.performAdd(t1);

		graph.performAdd(t2);

		graph.performAdd(t3);

		assertEquals(3, graph.getCount());

		final ExtendedIterator<Triple> friends = graph.find(null, NodeFactory.createURI("http://test/is_friend_of"), null);

		while (friends.hasNext()) {

			System.out.println(friends.next());

		}

	}

	private InputStream getResourceAsStream(final String classpath) {

		try {

			final ClassPathResource resource = new ClassPathResource(classpath);

			return resource.getInputStream();

		} catch (IOException e) {

			return null;

		}

	}

}