KnowledgeStoreClientTest.java

package eu.fbk.knowledgestore.client;

import java.util.Set;

import com.google.common.base.Joiner;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Ordering;
import com.google.common.collect.Sets;

import org.junit.Ignore;
import org.junit.Test;
import org.openrdf.model.URI;
import org.openrdf.model.impl.URIImpl;
import org.openrdf.model.vocabulary.DCTERMS;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import eu.fbk.knowledgestore.KnowledgeStore;
import eu.fbk.knowledgestore.Session;
import eu.fbk.knowledgestore.data.Criteria;
import eu.fbk.knowledgestore.data.Data;
import eu.fbk.knowledgestore.data.Record;
import eu.fbk.knowledgestore.data.Representation;
import eu.fbk.knowledgestore.data.Stream;
import eu.fbk.knowledgestore.internal.Util;
import eu.fbk.knowledgestore.vocabulary.KS;

public class KnowledgeStoreClientTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(Client.class);

    // TODO: intercept client-side connection close

    @Ignore
    @Test
    public void test2() throws Throwable {
        final Set<String> namespaces = Sets.newHashSet();
        final String query = "" //
                + "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
                + "PREFIX owl: <http://www.w3.org/2002/07/owl#>\n" //
                + "select distinct ?t\n" //
                + "where {\n" //
                + "  { ?s a ?t } union { ?t a rdfs:Class } union { ?t a owl:Class }\n" //
                + "  union { ?t rdfs:subClassOf ?x } union { ?y rdfs:subClassOf ?t }\n" //
                + "  filter (isIRI(?t))" + "}";

        final KnowledgeStore store = Client.builder("http://localhost:8080/")
                .maxConnections(2).validateServer(false).build();
        try {
            final Session session = store.newSession();
            final Stream<URI> uris = session.sparql(query).execTuples()
                    .transform(URI.class, true, "t");
            int index = 0;
            for (final URI uri : uris) {
                namespaces.add(uri.getNamespace());
                ++index;
                if (index % 10000 == 0) {
                    System.out.println(index + " URIs found");
                }
            }
            System.out.println(Joiner.on('\n').join(Ordering.natural().sortedCopy(namespaces)));
            uris.close();

        } finally {
            store.close();
        }
    }

    @Test
    public void test() throws Throwable {
        final KnowledgeStore store = Client.builder("http://localhost:8080/")
                .maxConnections(2).validateServer(false).build();
        try {
            final URI exampleID = new URIImpl("ex:test");
            final URI resourceID = new URIImpl(
                    "http://www.newsreader-project.eu/2013/4/30/589F-S2Y1-JD34-V1MC.xml");

            final Session session = store.newSession("ks", "kspass");

            System.out.println(serialize(session.retrieve(KS.RESOURCE)
                    .condition("not(dct:creator = 'Francesco')").exec()));

            session.count(KS.RESOURCE).condition("not(dct:creator = 'Francesco')").exec();

            // System.err.println(session.upload(exampleID).representation(null).exec());

            session.delete(KS.RESOURCE).ids(exampleID).exec();

            final Record record = Record.create(exampleID, KS.RESOURCE).set(DCTERMS.CREATOR,
                    "Francesco");
            session.merge(KS.RESOURCE).records(record).criteria(Criteria.overwrite()).exec();

            System.out.println(session.sparql("select (count(*) as ?n) where { ?s ?p ?o }")
                    .execTuples().transform(Integer.class, true, "n").getUnique());
            System.out.println(session
                    .sparql("describe <http://dbpedia.org/resource/Michael_Schumacher>")
                    .execTriples().count());

            session.merge(KS.RESOURCE).records(record).criteria(Criteria.overwrite()).exec();

            System.out.println(session.sparql(
                    "ask { <http://dbpedia.org/resource/David_Beckam> ?p ?o }").execBoolean());

            final Representation representation = session.download(resourceID).exec();
            System.out.println(representation.writeToString());
            System.out.println(serialize(ImmutableList.of(representation.getMetadata())));

            session.download(new URIImpl("ex:does-not-exist")).exec();

            System.out.println(session
                    .upload(exampleID)
                    .representation(
                            Representation.create("Nel bel mezzo del cammin di nostra vita"))
                    .exec());
        } catch (final Throwable ex) {
            LOGGER.error("Test failed", ex);
            Throwables.propagate(ex);

        } finally {
            store.close();
        }
    }

    private String serialize(final Iterable<Record> records) {
        final StringBuilder builder = new StringBuilder();
        try {
            int index = 0;
            for (final Record record : records) {
                builder.append("(").append(++index)
                        .append(") -----------------------------------------------------\n");
                builder.append(record.toString(Data.getNamespaceMap(), true)).append("\n\n");
            }
            return builder.toString();
        } finally {
            Util.closeQuietly(records);
        }

        // final ByteArrayOutputStream out = new ByteArrayOutputStream();
        // RDFUtil.writeRDF(RDFFormat.TURTLE, out, Data.getNamespaceMap(),
        // Record.encode(Stream.create(records), ImmutableSet.<URI>of()));
        // return new String(out.toByteArray());
    }
}