Example usage for org.apache.commons.rdf.api Dataset add

Introduction

In this page you can find the example usage for org.apache.commons.rdf.api Dataset add.

Prototype

void add(BlankNodeOrIRI graphName, BlankNodeOrIRI subject, IRI predicate, RDFTerm object);

Source Link

Document

Add a quad to the dataset, possibly mapping any of the components to those supported by this dataset.

Usage

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpRsWithoutBaseUrl() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();//from   ww  w  .  ja va 2 s .  co m

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("title"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.RDFSource).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.RDFSource, 1L, 1L, 0L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpNr() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*  w w  w  .jav  a 2  s  .c o  m*/

    final IRI binaryIdentifier = rdf.createIRI("foo:binary");
    final Dataset dataset = rdf.createDataset();
    final BinaryMetadata binary = BinaryMetadata.builder(binaryIdentifier).mimeType("text/plain").build();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("title"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(
                    svc.create(builder(resource).interactionModel(LDP.NonRDFSource).container(root)
                            .binary(binary).build(), dataset).toCompletableFuture(),
                    svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.NonRDFSource, 1L, 1L, 0L))
            .toCompletableFuture(),
            svc.get(resource)
                    .thenAccept(
                            res -> assertAll("Check binary", checkBinary(res, binaryIdentifier, "text/plain")))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();

    final IRI resource3 = rdf.createIRI(TRELLIS_DATA_PREFIX + "resource/notachild");
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, resource3, DC.title, rdf.createLiteral("title"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(() -> svc.create(builder(resource3).interactionModel(LDP.RDFSource).build(), dataset)
            .toCompletableFuture().join(), "Unsuccessful create operation!");

    allOf(svc.get(resource3).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, resource3, LDP.RDFSource, evenLater));
        assertAll("Check resource stream", checkResourceStream(res, 1L, 0L, 1L, 0L, 0L));
        assertFalse(res.getBinaryMetadata().isPresent(), "Unexpected binary metadata!");
    }).toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater)).toCompletableFuture(),
            svc.get(root)
                    .thenAccept(res -> assertFalse(res.getBinaryMetadata().isPresent(),
                            "unexpected binary metadata!"))
                    .toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(later, LDP.NonRDFSource, 1L, 1L, 0L))
                    .toCompletableFuture(),
            svc.get(resource).thenAccept(checkPredates(evenLater)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpC() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();//from   w w  w. ja va 2s .  c  o  m

    final Dataset dataset = rdf.createDataset();
    final BlankNode bnode = rdf.createBlankNode();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("resource"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.alternative, rdf.createLiteral("alt title"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description, rdf.createLiteral("description"));
    dataset.add(Trellis.PreferAudit, resource, PROV.wasGeneratedBy, bnode);
    dataset.add(Trellis.PreferAudit, bnode, RDF.type, PROV.Activity);
    dataset.add(Trellis.PreferAudit, bnode, RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.Container).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.Container, 3L, 3L, 0L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();

    // Now add a child resource
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("child"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(evenLater, 1L, 1L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater, LDP.Container, 3L, 3L, 1L))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater)).toCompletableFuture()).join();

    // Now update that child resource
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.description, rdf.createLiteral("a description"));
    dataset.add(Trellis.PreferUserManaged, child, RDFS.label, rdf.createLiteral("other title"));
    dataset.add(Trellis.PreferUserManaged, child, RDFS.seeAlso, rdf.createIRI("http://example.com"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Update);

    final Instant evenLater2 = meanwhile();

    assertDoesNotThrow(() -> svc
            .replace(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
            .toCompletableFuture().join(), "Unsuccessful create operation!");
    allOf(svc.get(child).thenAccept(checkChild(evenLater2, 3L, 2L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater, LDP.Container, 3L, 3L, 1L))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater2)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkPredates(evenLater2)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testAddAuditTriples() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*from  ww w .ja  v a  2s.c  o  m*/

    final Dataset dataset1 = rdf.createDataset();
    final Dataset dataset2 = rdf.createDataset();
    final BlankNode bnode = rdf.createBlankNode();
    dataset1.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("resource"));
    dataset1.add(Trellis.PreferUserManaged, resource, DC.alternative, rdf.createLiteral("alt title"));
    dataset2.add(Trellis.PreferAudit, resource, PROV.wasGeneratedBy, bnode);
    dataset2.add(Trellis.PreferAudit, bnode, RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(() -> allOf(
            svc.create(builder(resource).interactionModel(LDP.Container).container(root).build(), dataset1)
                    .toCompletableFuture(),
            svc.add(resource, dataset2).toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.Container, 2L, 2L, 0L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutDeleteLdpC() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*from  w  w w . j  a va 2  s.c o m*/

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("resource title"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description, rdf.createLiteral("resource description"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.Container).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.Container, 2L, 1L, 0L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();

    // Now add a child resource
    dataset.clear();
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("child"));
    dataset.add(Trellis.PreferUserManaged, child, DC.description, rdf.createLiteral("nested resource"));

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(evenLater, 2L, 1L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater, LDP.Container, 2L, 1L, 1L))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater)).toCompletableFuture()).join();

    // Now delete the child resource
    final BlankNode bnode = rdf.createBlankNode();
    dataset.clear();
    dataset.add(Trellis.PreferAudit, bnode, RDF.type, AS.Delete);
    dataset.add(Trellis.PreferAudit, bnode, RDF.type, PROV.Activity);
    dataset.add(Trellis.PreferServerManaged, child, RDF.type, LDP.Resource);

    final Instant preDelete = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc.delete(builder(child).interactionModel(LDP.RDFSource).container(resource).build())
                    .toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful delete operation!");

    allOf(svc.get(child).thenAccept(res -> assertEquals(DELETED_RESOURCE, res, "Incorrect resource object!"))
            .toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(preDelete, LDP.Container, 2L, 1L, 0L))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(preDelete)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpBc() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*from w  w w.  j  a  va 2 s . co m*/

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("title"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.alternative, rdf.createLiteral("alt title"));
    dataset.add(Trellis.PreferUserManaged, resource, RDFS.label, rdf.createLiteral("a label"));

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(
                    svc.create(builder(resource).interactionModel(LDP.BasicContainer).container(root).build(),
                            dataset).toCompletableFuture(),
                    svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.BasicContainer, 3L, 0L, 0L))
            .toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture())
                    .join();

    // Now add a child resource
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("title"));
    dataset.add(Trellis.PreferUserManaged, child, RDFS.label, rdf.createLiteral("label"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(evenLater, 2L, 1L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater, LDP.BasicContainer, 3L, 0L, 1L))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater)).toCompletableFuture()).join();

    // Now update the child resource
    dataset.clear();
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Update);
    dataset.add(Trellis.PreferUserManaged, child, RDFS.seeAlso, rdf.createIRI("http://www.example.com/"));
    dataset.add(Trellis.PreferUserManaged, child, RDFS.label, rdf.createLiteral("a label"));

    final Instant evenLater2 = meanwhile();

    assertDoesNotThrow(() -> svc
            .replace(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
            .toCompletableFuture().join(), "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(evenLater2, 2L, 2L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater, LDP.BasicContainer, 3L, 0L, 1L))
                    .toCompletableFuture(),
            svc.get(resource).thenAccept(checkPredates(evenLater2)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater2)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpDcSelf() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();//from w ww .jav a  2  s .c o m

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("direct container"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.alternative, rdf.createLiteral("alt title"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description,
            rdf.createLiteral("LDP-DC pointing to self"));
    dataset.add(Trellis.PreferUserManaged, resource, LDP.membershipResource, resource);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.hasMemberRelation, DC.relation);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.DirectContainer).membershipResource(resource)
                            .memberRelation(DC.relation).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 5L, 0L, 0L))
            .toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture())
                    .join();

    // Now add the child resources to the ldp-dc
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("ldp-dc (self) child resource"));

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(evenLater, 1L, 0L)).toCompletableFuture(),
            svc.get(resource).thenAccept(res -> {
                assertAll("Check resource", checkResource(res, resource, LDP.DirectContainer, evenLater));
                assertAll("Check resource stream", checkResourceStream(res, 5L, 0L, 0L, 1L, 1L));
                assertTrue(
                        res.stream(LDP.PreferContainment)
                                .anyMatch(isEqual(rdf.createTriple(resource, LDP.contains, child))),
                        "Missing contains triple!");
                assertTrue(
                        res.stream(LDP.PreferMembership)
                                .anyMatch(isEqual(rdf.createTriple(resource, DC.relation, child))),
                        "Missing membership triple!");
            }).toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpDc() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*  ww  w.  j  a  v a2  s . c o  m*/

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("direct container"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description, rdf.createLiteral("LDP-DC test"));
    dataset.add(Trellis.PreferUserManaged, resource, LDP.membershipResource, members);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.hasMemberRelation, DC.relation);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.DirectContainer).container(root)
                            .memberRelation(DC.relation).membershipResource(members).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 4L, 0L, 0L))
            .toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture())
                    .join();

    // Now add a membership resource
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, members, DC.title, rdf.createLiteral("member resource"));

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(members).interactionModel(LDP.RDFSource).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(members).thenAccept(checkMember(evenLater, 1L, 0L, 0L)).toCompletableFuture(), svc
            .get(members)
            .thenAccept(res -> assertFalse(res.getBinaryMetadata().isPresent(), "Unexpected binary metadata!"))
            .toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 4L, 0L, 0L))
                    .toCompletableFuture(),
            svc.get(resource).thenAccept(checkPredates(evenLater)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(evenLater, 2L)).toCompletableFuture()).join();

    // Now add the child resources to the ldp-dc
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("ldp-dc child resource"));

    final Instant evenLater2 = meanwhile();

    assertDoesNotThrow(() -> allOf(
            svc.create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(),
            svc.touch(members).toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(evenLater2, 1L, 0L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater2, LDP.DirectContainer, 4L, 0L, 1L))
                    .toCompletableFuture(),
            svc.get(resource)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferContainment)
                                    .anyMatch(isEqual(rdf.createTriple(resource, LDP.contains, child))),
                            "Missing contains triple!"))
                    .toCompletableFuture(),
            svc.get(members).thenAccept(checkMember(evenLater2, 1L, 0L, 1L)).toCompletableFuture(),
            svc.get(members)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferMembership)
                                    .anyMatch(isEqual(rdf.createTriple(members, DC.relation, child))),
                            "Missing membership triple!"))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(evenLater, 2L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater2)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpDcMultiple() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();//  w  w  w  .j av a 2  s .  c o m

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("direct container"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description, rdf.createLiteral("multiple LDP-DC test"));
    dataset.add(Trellis.PreferUserManaged, resource, LDP.membershipResource, members);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.hasMemberRelation, DC.relation);
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.DirectContainer).container(root)
                            .membershipResource(members).memberRelation(DC.relation).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 4L, 1L, 0L))
            .toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture())
                    .join();

    dataset.clear();
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);
    dataset.add(Trellis.PreferUserManaged, resource2, DC.title, rdf.createLiteral("second LDP-DC"));
    dataset.add(Trellis.PreferUserManaged, resource2, DC.description, rdf.createLiteral("another LDP-DC"));
    dataset.add(Trellis.PreferUserManaged, resource2, RDFS.label, rdf.createLiteral("test multple LDP-DCs"));
    dataset.add(Trellis.PreferUserManaged, resource2, SKOS.prefLabel,
            rdf.createLiteral("test multple LDP-DCs"));
    dataset.add(Trellis.PreferUserManaged, resource2, LDP.membershipResource, members);
    dataset.add(Trellis.PreferUserManaged, resource2, LDP.hasMemberRelation, DC.subject);

    final Instant later2 = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource2).interactionModel(LDP.DirectContainer).container(root)
                            .membershipResource(members).memberRelation(DC.subject).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource2).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, resource2, LDP.DirectContainer, later2));
        assertAll("Check resource stream", checkResourceStream(res, 6L, 0L, 1L, 0L, 0L));
    }).toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later2, 2L)).toCompletableFuture()).join();

    // Now add a membership resource
    dataset.clear();
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);
    dataset.add(Trellis.PreferUserManaged, members, DC.title, rdf.createLiteral("member resource"));
    dataset.add(Trellis.PreferUserManaged, members, DC.description,
            rdf.createLiteral("LDP-RS membership test"));

    final Instant later3 = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(members).interactionModel(LDP.RDFSource).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(members).thenAccept(checkMember(later3, 2L, 1L, 0L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 4L, 1L, 0L))
                    .toCompletableFuture(),
            svc.get(resource).thenAccept(checkPredates(later3)).toCompletableFuture(),
            svc.get(resource2).thenAccept(checkPredates(later3)).toCompletableFuture(),
            svc.get(resource2)
                    .thenAccept(res -> assertAll("Check resource stream",
                            checkResourceStream(res, 6L, 0L, 1L, 0L, 0L)))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later3, 3L)).toCompletableFuture()).join();

    // Now add the child resources to the ldp-dc
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("ldp-dc (1) child resource"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant later4 = meanwhile();

    assertDoesNotThrow(() -> allOf(
            svc.create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(),
            svc.touch(resource).toCompletableFuture(), svc.touch(members).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(checkChild(later4, 1L, 1L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(later2, LDP.DirectContainer, 4L, 1L, 1L))
                    .toCompletableFuture(),
            svc.get(resource)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferContainment)
                                    .anyMatch(isEqual(rdf.createTriple(resource, LDP.contains, child))),
                            "Missing contains triple!"))
                    .toCompletableFuture(),
            svc.get(members).thenAccept(checkMember(later4, 2L, 1L, 1L)).toCompletableFuture(),
            svc.get(members)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferMembership)
                                    .anyMatch(isEqual(rdf.createTriple(members, DC.relation, child))),
                            "Missing membership triple!"))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later3, 3L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(later4)).toCompletableFuture()).join();

    // Now add a child resources to the other ldp-dc
    dataset.clear();
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);
    dataset.add(Trellis.PreferUserManaged, child2, DC.title, rdf.createLiteral("ldp-dc (2) child resource"));

    final Instant later5 = meanwhile();

    assertDoesNotThrow(() -> allOf(
            svc.create(builder(child2).interactionModel(LDP.RDFSource).container(resource2).build(), dataset)
                    .toCompletableFuture(),
            svc.touch(members).toCompletableFuture(), svc.touch(resource2).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child2).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, child2, LDP.RDFSource, later5));
        assertAll("Check resource stream", checkResourceStream(res, 1L, 0L, 1L, 0L, 0L));
    }).toCompletableFuture(), svc.get(resource2).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, resource2, LDP.DirectContainer, later5));
        assertAll("Check resource stream", checkResourceStream(res, 6L, 0L, 1L, 0L, 1L));
        assertTrue(
                res.stream(LDP.PreferContainment)
                        .anyMatch(isEqual(rdf.createTriple(resource2, LDP.contains, child2))),
                "Missing contains triple!");
    }).toCompletableFuture(),
            svc.get(members).thenAccept(checkMember(later5, 2L, 1L, 2L)).toCompletableFuture(),
            svc.get(members)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferMembership)
                                    .anyMatch(isEqual(rdf.createTriple(members, DC.subject, child2))),
                            "Missing membership triple!"))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(later3, 3L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(later5)).toCompletableFuture()).join();
}

---

From source file:org.trellisldp.triplestore.TriplestoreResourceServiceTest.java

@Test
public void testPutLdpDcMultipleInverse() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*from  ww  w.  j  a va  2s.  c o  m*/

    final Dataset dataset = rdf.createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("direct container inverse"));
    dataset.add(Trellis.PreferUserManaged, resource, RDFS.label, rdf.createLiteral("LDP-DC test"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description, rdf.createLiteral("LDP-DC inverse test"));
    dataset.add(Trellis.PreferUserManaged, resource, LDP.membershipResource, members);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.isMemberOfRelation, DC.relation);
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource).interactionModel(LDP.DirectContainer).container(root)
                            .membershipResource(members).memberOfRelation(DC.relation).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 5L, 1L, 0L))
            .toCompletableFuture(), svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture())
                    .join();

    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, resource2, DC.title, rdf.createLiteral("Second LDP-DC"));
    dataset.add(Trellis.PreferUserManaged, resource2, LDP.membershipResource, members);
    dataset.add(Trellis.PreferUserManaged, resource2, LDP.isMemberOfRelation, DC.subject);
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant evenLater = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(resource2).interactionModel(LDP.DirectContainer).container(root)
                            .membershipResource(members).memberOfRelation(DC.subject).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(resource2).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, resource2, LDP.DirectContainer, evenLater));
        assertAll("Check resource stream", checkResourceStream(res, 3L, 0L, 1L, 0L, 0L));
    }).toCompletableFuture(), svc.get(root).thenAccept(checkRoot(evenLater, 2L)).toCompletableFuture()).join();

    // Now add a membership resource
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, members, DC.title, rdf.createLiteral("Membership resource"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant evenLater2 = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(members).interactionModel(LDP.RDFSource).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful membership resource create operation!");

    allOf(svc.get(members).thenAccept(checkMember(evenLater2, 1L, 1L, 0L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(later, LDP.DirectContainer, 5L, 1L, 0L))
                    .toCompletableFuture(),
            svc.get(resource).thenAccept(checkPredates(evenLater2)).toCompletableFuture(),
            svc.get(resource2).thenAccept(checkPredates(evenLater2)).toCompletableFuture(),
            svc.get(resource2)
                    .thenAccept(res -> assertAll("Check resource stream",
                            checkResourceStream(res, 3L, 0L, 1L, 0L, 0L)))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(evenLater2, 3L)).toCompletableFuture()).join();

    // Now add the child resources to the ldp-dc
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, DC.title, rdf.createLiteral("Child resource"));
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);

    final Instant evenLater3 = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc
                    .create(builder(child).interactionModel(LDP.RDFSource).container(resource).build(), dataset)
                    .toCompletableFuture(), svc.touch(resource).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, child, LDP.RDFSource, evenLater3));
        assertAll("Check resource stream", checkResourceStream(res, 1L, 0L, 1L, 1L, 0L));
    }).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater3, LDP.DirectContainer, 5L, 1L, 1L))
                    .toCompletableFuture(),
            svc.get(resource)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferContainment)
                                    .anyMatch(isEqual(rdf.createTriple(resource, LDP.contains, child))),
                            "Missing contains triple!"))
                    .toCompletableFuture(),
            svc.get(members).thenAccept(checkMember(evenLater2, 1L, 1L, 0L)).toCompletableFuture(),
            svc.get(members).thenAccept(checkPredates(evenLater3)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(evenLater2, 3L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater3)).toCompletableFuture()).join();

    // Now add a child resources to the other ldp-dc
    dataset.clear();
    dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);
    dataset.add(Trellis.PreferUserManaged, child2, DC.title, rdf.createLiteral("Second child resource"));

    final Instant evenLater4 = meanwhile();

    assertDoesNotThrow(
            () -> allOf(svc.create(builder(child2).interactionModel(LDP.RDFSource).container(resource2).build(),
                    dataset).toCompletableFuture(), svc.touch(resource2).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

    allOf(svc.get(child2).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, child2, LDP.RDFSource, evenLater4));
        assertAll("Check resource stream", checkResourceStream(res, 1L, 0L, 1L, 1L, 0L));
    }).toCompletableFuture(), svc.get(resource2).thenAccept(res -> {
        assertAll("Check resource", checkResource(res, resource2, LDP.DirectContainer, evenLater4));
        assertAll("Check resource stream", checkResourceStream(res, 3L, 0L, 1L, 0L, 1L));
        assertTrue(
                res.stream(LDP.PreferContainment)
                        .anyMatch(isEqual(rdf.createTriple(resource2, LDP.contains, child2))),
                "Missing contains triple!");
    }).toCompletableFuture(),
            svc.get(members).thenAccept(checkMember(evenLater2, 1L, 1L, 0L)).toCompletableFuture(),
            svc.get(members).thenAccept(checkPredates(evenLater4)).toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(evenLater2, 3L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater4)).toCompletableFuture()).join();
}

---

• «
• 1
• 2
• 3
• »