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

Introduction

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

Prototype

@Override
void clear();

Source Link

Document

Clear the dataset, removing all quads.

Usage

From source file:org.trellisldp.test.ResourceServiceTests.java

/**
 * Test replacing a resource./*from w ww  . j  a v  a2 s.  c  o  m*/
 * @throws Exception if the operation failed
 */
@Test
@DisplayName("Test replacing resource")
default void testReplaceResource() throws Exception {
    final RDF rdf = getInstance();
    final IRI identifier = rdf.createIRI(TRELLIS_DATA_PREFIX + getResourceService().generateIdentifier());
    final Dataset dataset = buildDataset(identifier, "Replacement Test", SUBJECT2);

    assertEquals(MISSING_RESOURCE, getResourceService().get(identifier).toCompletableFuture().join(),
            "Check for no pre-existing LDP-RS");
    assertDoesNotThrow(
            () -> getResourceService().create(Metadata.builder(identifier).interactionModel(LDP.RDFSource)
                    .container(ROOT_CONTAINER).build(), dataset).toCompletableFuture().join(),
            "Check that the LDP-RS was successfully created");

    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, identifier, SKOS.prefLabel, rdf.createLiteral("preferred label"));
    dataset.add(Trellis.PreferUserManaged, identifier, SKOS.altLabel, rdf.createLiteral("alternate label"));
    dataset.add(Trellis.PreferUserManaged, identifier, type, SKOS.Concept);

    assertDoesNotThrow(
            () -> getResourceService().replace(Metadata.builder(identifier).interactionModel(LDP.RDFSource)
                    .container(ROOT_CONTAINER).build(), dataset).toCompletableFuture().join(),
            "Check that the LDP-RS was successfully replaced");
    final Resource res = getResourceService().get(identifier).toCompletableFuture().join();
    assertAll("Check the replaced LDP-RS stream",
            res.stream(Trellis.PreferUserManaged).map(toQuad(Trellis.PreferUserManaged))
                    .map(q -> () -> assertTrue(dataset.contains(q),
                            "Check that the quad comes from the dataset: " + q)));
    assertEquals(3L, res.stream(Trellis.PreferUserManaged).count(),
            "Check the total user-managed triple count");
}

---

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();/*from w  w  w .  j av a  2  s.co 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  ww . j  a v a 2s. co  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 testPutDeleteLdpC() throws Exception {
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*from 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("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();//w  w w .j a  v  a  2s.c om

    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  w  w.  ja  v 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();/* w ww .  j ava2s.  co  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();//from   ww w . ja va 2 s.c  om

    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 v a 2  s.  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();
}

---

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

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

    final Dataset dataset = rdf.createDataset();
    final BlankNode bnode0 = rdf.createBlankNode();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("Indirect Container"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.description, rdf.createLiteral("Test LDP-IC"));
    dataset.add(Trellis.PreferUserManaged, resource, DC.subject, rdf.createIRI("http://example.com/subject"));
    dataset.add(Trellis.PreferUserManaged, resource, RDF.type, SKOS.Concept);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.membershipResource, members);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.hasMemberRelation, RDFS.label);
    dataset.add(Trellis.PreferUserManaged, resource, LDP.insertedContentRelation, SKOS.prefLabel);
    dataset.add(Trellis.PreferAudit, resource, PROV.wasGeneratedBy, bnode0);
    dataset.add(Trellis.PreferAudit, bnode0, PROV.atTime, rdf.createLiteral(now().toString(), XSD.dateTime));
    dataset.add(Trellis.PreferAudit, bnode0, RDF.type, PROV.Activity);
    dataset.add(Trellis.PreferAudit, bnode0, RDF.type, AS.Create);

    final Instant later = meanwhile();

    assertDoesNotThrow(() -> allOf(
            svc.create(builder(resource).interactionModel(LDP.IndirectContainer).container(root)
                    .membershipResource(members).memberRelation(RDFS.label)
                    .insertedContentRelation(SKOS.prefLabel).build(), dataset).toCompletableFuture(),
            svc.touch(root).toCompletableFuture()).join(), "Unsuccessful create operation!");

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

    // Now add a membership resource
    final BlankNode bnode1 = rdf.createBlankNode();
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, members, DC.title, rdf.createLiteral("Membership resource"));
    dataset.add(Trellis.PreferAudit, members, PROV.wasGeneratedBy, bnode1);
    dataset.add(Trellis.PreferAudit, bnode1, PROV.atTime, rdf.createLiteral(now().toString(), XSD.dateTime));
    dataset.add(Trellis.PreferAudit, bnode1, RDF.type, PROV.Activity);
    dataset.add(Trellis.PreferAudit, bnode1, RDF.type, AS.Create);

    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, 4L, 0L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(later, LDP.IndirectContainer, 7L, 4L, 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
    final BlankNode bnode2 = rdf.createBlankNode();
    final Literal label = rdf.createLiteral("label-1");
    dataset.clear();
    dataset.add(Trellis.PreferUserManaged, child, SKOS.prefLabel, label);
    dataset.add(Trellis.PreferAudit, child, PROV.wasGeneratedBy, bnode2);
    dataset.add(Trellis.PreferAudit, bnode2, RDF.type, AS.Create);
    dataset.add(Trellis.PreferAudit, bnode2, RDF.type, PROV.Activity);

    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, 3L)).toCompletableFuture(),
            svc.get(resource).thenAccept(checkResource(evenLater2, LDP.IndirectContainer, 7L, 4L, 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, 4L, 1L)).toCompletableFuture(),
            svc.get(members)
                    .thenAccept(res -> assertTrue(
                            res.stream(LDP.PreferMembership)
                                    .anyMatch(isEqual(rdf.createTriple(members, RDFS.label, label))),
                            "Missing member triple!"))
                    .toCompletableFuture(),
            svc.get(root).thenAccept(checkRoot(evenLater, 2L)).toCompletableFuture(),
            svc.get(root).thenAccept(checkPredates(evenLater2)).toCompletableFuture()).join();
}

---

• «
• 1
• 2
• »