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.test.MementoResourceTests.java

/**
 * Test the content of memento resources.
 *///from  ww w.  j ava 2 s  .co m
@Test
@DisplayName("Test the content of memento resources")
default void testMementoContent() {
    final RDF rdf = getInstance();
    final Dataset dataset = rdf.createDataset();
    final Map<String, String> mementos = getMementos();
    mementos.forEach((memento, date) -> {
        try (final Response res = target(memento).request().get()) {
            assertEquals(SUCCESSFUL, res.getStatusInfo().getFamily(), "Check for a successful request");
            readEntityAsGraph(res.getEntity(), getBaseURL(), TURTLE).stream()
                    .forEach(triple -> dataset.add(rdf.createIRI(memento), triple.getSubject(),
                            triple.getPredicate(), triple.getObject()));
        }
    });

    final IRI subject = rdf.createIRI(getResourceLocation());
    final List<IRI> urls = mementos.keySet().stream().sorted().map(rdf::createIRI).collect(toList());
    assertEquals(3L, urls.size(), "Check that three mementos were found");
    assertTrue(dataset.getGraph(urls.get(0)).isPresent(), "Check that the first graph is present");
    dataset.getGraph(urls.get(0)).ifPresent(g -> {
        assertTrue(g.contains(subject, type, SKOS.Concept), "Check for a skos:Concept type");
        assertTrue(g.contains(subject, SKOS.prefLabel, rdf.createLiteral("Resource Name", "eng")),
                "Check for a skos:prefLabel property");
        assertTrue(g.contains(subject, DC.subject, rdf.createIRI("http://example.org/subject/1")),
                "Check for a dc:subject property");
        assertEquals(3L, g.size(), "Check for three triples");
    });

    assertTrue(dataset.getGraph(urls.get(1)).isPresent(), "Check that the second graph is present");
    dataset.getGraph(urls.get(1)).ifPresent(g -> {
        assertTrue(g.contains(subject, type, SKOS.Concept), "Check for a skos:Concept type");
        assertTrue(g.contains(subject, SKOS.prefLabel, rdf.createLiteral("Resource Name", "eng")),
                "Check for a skos:prefLabel property");
        assertTrue(g.contains(subject, DC.subject, rdf.createIRI("http://example.org/subject/1")),
                "Check for a dc:subject property");
        assertTrue(g.contains(subject, DC.title, rdf.createLiteral("Title")), "Check for a dc:title property");
        assertEquals(4L, g.size(), "Check for four triples");
    });

    assertTrue(dataset.getGraph(urls.get(2)).isPresent(), "Check that the third graph is present");
    dataset.getGraph(urls.get(2)).ifPresent(g -> {
        assertTrue(g.contains(subject, type, SKOS.Concept), "Check for a skos:Concept type");
        assertTrue(g.contains(subject, SKOS.prefLabel, rdf.createLiteral("Resource Name", "eng")),
                "Check for a skos:prefLabel property");
        assertTrue(g.contains(subject, DC.subject, rdf.createIRI("http://example.org/subject/1")),
                "Check for a dc:subject property");
        assertTrue(g.contains(subject, DC.title, rdf.createLiteral("Title")), "Check for a dc:title property");
        assertTrue(g.contains(subject, DC.alternative, rdf.createLiteral("Alternative Title")),
                "Check for a dc:alternative property");
        assertEquals(5L, g.size(), "Check for five triples");
    });
}

---

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

/**
 * Test replacing a resource.// w ww  . jav a2  s .  c  om
 * @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.test.ResourceServiceTests.java

/**
 * Test adding immutable data.//  ww  w  . j a  v  a 2  s .  c  o  m
 * @throws Exception if the operation failed
 */
@Test
@DisplayName("Test adding immutable data")
default void testAddImmutableData() throws Exception {
    final RDF rdf = getInstance();
    final IRI identifier = rdf.createIRI(TRELLIS_DATA_PREFIX + getResourceService().generateIdentifier());
    final Dataset dataset0 = buildDataset(identifier, "Immutable Resource Test", SUBJECT2);

    assertDoesNotThrow(
            () -> getResourceService().create(Metadata.builder(identifier).interactionModel(LDP.RDFSource)
                    .container(ROOT_CONTAINER).build(), dataset0).toCompletableFuture().join(),
            "Check the successful creation of an LDP-RS");

    final IRI audit1 = rdf.createIRI(TRELLIS_BNODE_PREFIX + getResourceService().generateIdentifier());
    final Dataset dataset1 = rdf.createDataset();
    dataset1.add(Trellis.PreferAudit, identifier, PROV.wasGeneratedBy, audit1);
    dataset1.add(Trellis.PreferAudit, audit1, type, PROV.Activity);
    dataset1.add(Trellis.PreferAudit, audit1, type, AS.Create);
    dataset1.add(Trellis.PreferAudit, audit1, PROV.atTime, rdf.createLiteral(now().toString(), XSD.dateTime));

    assertDoesNotThrow(() -> getResourceService().add(identifier, dataset1).toCompletableFuture().join(),
            "Check the successful addition of audit quads");

    final Resource res = getResourceService().get(identifier).toCompletableFuture().join();
    assertAll("Check the audit stream", res.stream(Trellis.PreferAudit).map(toQuad(Trellis.PreferAudit))
            .map(q -> () -> assertTrue(dataset1.contains(q), "Check that the audit stream includes: " + q)));
    assertEquals(4L, res.stream(Trellis.PreferAudit).count(), "Check the audit triple count");

    final IRI audit2 = rdf.createIRI(TRELLIS_BNODE_PREFIX + getResourceService().generateIdentifier());
    final Dataset dataset2 = rdf.createDataset();
    dataset2.add(Trellis.PreferAudit, identifier, PROV.wasGeneratedBy, audit2);
    dataset2.add(Trellis.PreferAudit, audit2, type, PROV.Activity);
    dataset2.add(Trellis.PreferAudit, audit2, type, AS.Update);
    dataset2.add(Trellis.PreferAudit, audit2, PROV.atTime, rdf.createLiteral(now().toString(), XSD.dateTime));

    assertDoesNotThrow(() -> getResourceService().add(identifier, dataset2).toCompletableFuture().join(),
            "Check that audit triples are added successfully");

    final Resource res2 = getResourceService().get(identifier).toCompletableFuture().join();

    final Dataset combined = rdf.createDataset();
    dataset1.stream().forEach(combined::add);
    dataset2.stream().forEach(combined::add);

    assertAll("Check the audit stream", res2.stream(Trellis.PreferAudit).map(toQuad(Trellis.PreferAudit))
            .map(q -> () -> assertTrue(combined.contains(q), "Check that the audit stream includes: " + q)));
    assertEquals(8L, res2.stream(Trellis.PreferAudit).count(), "Check the audit triple count");
}

---

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

/**
 * Test an LDP:DirectContainer./* w w w.jav a 2 s .  c o  m*/
 * @throws Exception if the create operation fails
 */
@Test
@DisplayName("Test LDP-DC")
default void testLdpDC() throws Exception {
    // Only test DC if the backend supports it
    assumeTrue(getResourceService().supportedInteractionModels().contains(LDP.DirectContainer));

    final Instant time = now();
    final RDF rdf = getInstance();
    final String base = TRELLIS_DATA_PREFIX + getResourceService().generateIdentifier();
    final IRI identifier = rdf.createIRI(base);
    final IRI member = rdf.createIRI(base + "/member");
    final Dataset dataset0 = buildDataset(identifier, "Direct Container Test", SUBJECT0);
    dataset0.add(Trellis.PreferUserManaged, identifier, LDP.membershipResource, member);
    dataset0.add(Trellis.PreferUserManaged, identifier, LDP.isMemberOfRelation, DC.isPartOf);

    assertEquals(MISSING_RESOURCE, getResourceService().get(identifier).toCompletableFuture().join(),
            "Check that the DC doesn't exist");
    assertDoesNotThrow(() -> getResourceService()
            .create(Metadata.builder(identifier).membershipResource(member).memberOfRelation(DC.isPartOf)
                    .interactionModel(LDP.DirectContainer).container(ROOT_CONTAINER).build(), dataset0)
            .toCompletableFuture().join(), "Check that creating the LDP-DC succeeds");

    final IRI child1 = rdf.createIRI(base + "/child1");
    final Dataset dataset1 = buildDataset(child1, "Child 1", SUBJECT1);

    assertEquals(MISSING_RESOURCE, getResourceService().get(child1).toCompletableFuture().join(),
            "Check that no child resource exists");
    assertDoesNotThrow(
            () -> getResourceService().create(
                    Metadata.builder(child1).interactionModel(LDP.RDFSource).container(identifier).build(),
                    dataset1).toCompletableFuture().join(),
            "Check that the child resource is successfully created");

    final IRI child2 = rdf.createIRI(base + "/child2");
    final Dataset dataset2 = buildDataset(child2, "Child 2", SUBJECT2);

    assertEquals(MISSING_RESOURCE, getResourceService().get(child2).toCompletableFuture().join(),
            "Check that no child2 resource exists");
    assertDoesNotThrow(
            () -> getResourceService().create(
                    Metadata.builder(child2).interactionModel(LDP.RDFSource).container(identifier).build(),
                    dataset2).toCompletableFuture().join(),
            "Check that the child2 resource is successfully created");

    final Resource res = getResourceService().get(identifier).toCompletableFuture().join();
    assertAll("Check the resource", checkResource(res, identifier, LDP.DirectContainer, time, dataset0));
    assertEquals(of(member), res.getMembershipResource(), "Check for ldp:membershipResource");
    assertEquals(of(DC.isPartOf), res.getMemberOfRelation(), "Check for ldp:isMemberOfRelation");
    assertFalse(res.getMemberRelation().isPresent(), "Check for no ldp:hasMemberRelation");
    assertFalse(res.getInsertedContentRelation().filter(isEqual(LDP.MemberSubject).negate()).isPresent(),
            "Check for no ldp:InsertedContentRelation, excepting ldp:MemberSubject");
    assertEquals(2L, res.stream(LDP.PreferContainment).count(), "Check the containment count");
    final Graph graph = rdf.createGraph();
    res.stream(LDP.PreferContainment).forEach(graph::add);
    assertTrue(graph.contains(identifier, LDP.contains, child1),
            "Check that child1 is contained in the LDP-DC");
    assertTrue(graph.contains(identifier, LDP.contains, child2),
            "Check that child2 is contained in the LDP-DC");
    assertEquals(5L, res.stream(Trellis.PreferUserManaged).count(), "Check the user-managed triple count");
}

---

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

/**
 * Test an LDP:IndirectContainer./*ww w.j av a2 s .c  o  m*/
 * @throws Exception if the create operation fails
 */
@Test
@DisplayName("Test LDP-IC")
default void testLdpIC() throws Exception {
    // Only execute this test if the backend supports it
    assumeTrue(getResourceService().supportedInteractionModels().contains(LDP.IndirectContainer));

    final Instant time = now();
    final RDF rdf = getInstance();
    final String base = TRELLIS_DATA_PREFIX + getResourceService().generateIdentifier();
    final IRI identifier = rdf.createIRI(base);
    final IRI member = rdf.createIRI(base + "/member");
    final Dataset dataset0 = buildDataset(identifier, "Indirect Container Test", SUBJECT0);
    dataset0.add(Trellis.PreferUserManaged, identifier, LDP.membershipResource, member);
    dataset0.add(Trellis.PreferUserManaged, identifier, LDP.hasMemberRelation, DC.relation);
    dataset0.add(Trellis.PreferUserManaged, identifier, LDP.insertedContentRelation, FOAF.primaryTopic);

    assertEquals(MISSING_RESOURCE, getResourceService().get(identifier).toCompletableFuture().join(),
            "Check for a missing resource");
    assertDoesNotThrow(() -> getResourceService().create(Metadata.builder(identifier).membershipResource(member)
            .memberRelation(DC.relation).insertedContentRelation(FOAF.primaryTopic)
            .interactionModel(LDP.IndirectContainer).container(ROOT_CONTAINER).build(), dataset0)
            .toCompletableFuture().join(), "Check that creating a resource succeeds");

    final IRI child1 = rdf.createIRI(base + "/child1");
    final Dataset dataset1 = buildDataset(child1, "Indirect Container Child 1", SUBJECT1);

    assertEquals(MISSING_RESOURCE, getResourceService().get(child1).toCompletableFuture().join(),
            "Check that the child resource doesn't exist");
    assertDoesNotThrow(() -> getResourceService()
            .create(Metadata.builder(child1).interactionModel(LDP.RDFSource).container(identifier).build(),
                    dataset1)
            .toCompletableFuture().join(), "Check that creating a child resource succeeds");

    final IRI child2 = rdf.createIRI(base + "/child2");
    final Dataset dataset2 = buildDataset(child2, "Indirect Container Child 2", SUBJECT2);

    assertEquals(MISSING_RESOURCE, getResourceService().get(child2).toCompletableFuture().join(),
            "Check that the child resource doesn't exist");
    assertDoesNotThrow(() -> getResourceService()
            .create(Metadata.builder(child2).interactionModel(LDP.RDFSource).container(identifier).build(),
                    dataset2)
            .toCompletableFuture().join(), "Check that creating the child resource succeeds");

    final Resource res = getResourceService().get(identifier).toCompletableFuture().join();
    assertAll("Check the resource", checkResource(res, identifier, LDP.IndirectContainer, time, dataset0));
    assertEquals(of(member), res.getMembershipResource(), "Check for ldp:membershipResource");
    assertEquals(of(DC.relation), res.getMemberRelation(), "Check for ldp:hasMemberRelation");
    assertEquals(of(FOAF.primaryTopic), res.getInsertedContentRelation(),
            "Check for ldp:insertedContentRelation");
    assertFalse(res.getMemberOfRelation().isPresent(), "Check for no ldp:isMemberOfRelation");
    assertEquals(2L, res.stream(LDP.PreferContainment).count(), "Check the containment triple count");
    final Graph graph = rdf.createGraph();
    res.stream(LDP.PreferContainment).forEach(graph::add);
    assertTrue(graph.contains(identifier, LDP.contains, child1),
            "Check that child1 is contained in the LDP-IC");
    assertTrue(graph.contains(identifier, LDP.contains, child2),
            "Check that child2 is contained in the LDP-IC");
    assertEquals(6L, res.stream(Trellis.PreferUserManaged).count(), "Check the total triple count");
}

---

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

/**
 * Build a dataset./*  w ww. java  2  s .  c  om*/
 * @param resource the resource IRI
 * @param title a title
 * @param subject a subject
 * @return a new dataset
 */
default Dataset buildDataset(final IRI resource, final String title, final String subject) {
    final Dataset dataset = getInstance().createDataset();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, getInstance().createLiteral(title));
    dataset.add(Trellis.PreferUserManaged, resource, DC.subject, getInstance().createIRI(subject));
    dataset.add(Trellis.PreferUserManaged, resource, type, SKOS.Concept);
    return dataset;
}

---

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

private void createOrReplace(final Metadata metadata, final Dataset dataset, final OperationType type) {
    final Instant eventTime = now();

    // Set the LDP type
    dataset.add(PreferServerManaged, metadata.getIdentifier(), RDF.type, metadata.getInteractionModel());

    // Relocate some user-managed triples into the server-managed graph
    metadata.getMembershipResource().ifPresent(member -> {
        dataset.add(PreferServerManaged, metadata.getIdentifier(), LDP.member, getBaseIRI(member));
        dataset.add(PreferServerManaged, metadata.getIdentifier(), LDP.membershipResource, member);
    });/* ww w.  j ava  2  s  . c o  m*/

    metadata.getMemberRelation().ifPresent(relation -> dataset.add(PreferServerManaged,
            metadata.getIdentifier(), LDP.hasMemberRelation, relation));

    metadata.getMemberOfRelation().ifPresent(relation -> dataset.add(PreferServerManaged,
            metadata.getIdentifier(), LDP.isMemberOfRelation, relation));

    if (asList(LDP.IndirectContainer, LDP.DirectContainer).contains(metadata.getInteractionModel())) {
        dataset.add(PreferServerManaged, metadata.getIdentifier(), LDP.insertedContentRelation,
                metadata.getInsertedContentRelation().orElse(LDP.MemberSubject));
    }

    // Set the parent relationship
    metadata.getContainer().ifPresent(
            parent -> dataset.add(PreferServerManaged, metadata.getIdentifier(), DC.isPartOf, parent));

    metadata.getBinary().ifPresent(binary -> {
        dataset.add(PreferServerManaged, metadata.getIdentifier(), DC.hasPart, binary.getIdentifier());
        binary.getMimeType().map(rdf::createLiteral).ifPresent(
                mimeType -> dataset.add(PreferServerManaged, binary.getIdentifier(), DC.format, mimeType));
    });

    storeResource(metadata.getIdentifier(), dataset, eventTime, type);
}

---

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

/**
 * This is equivalent to the SPARQL below.
 *
 * <p><pre><code>//from   w w  w. j a va  2  s .c  o  m
 * DELETE WHERE { GRAPH IDENTIFIER { ?s ?p ?o } };
 * DELETE WHERE { GRAPH IDENTIFIER?ext=acl { ?s ?p ?o } };
 * DELETE WHERE { GRAPH trellis:PreferServerManaged {
 *   IDENTIFIER a ldp:NonRDFSource .
 *   IDENTIFIER dc:hasPart ?s .
 *   ?s ?p ?o .
 * };
 * DELETE WHERE { GRAPH trellis:PreferServerManaged { IDENTIFIER ?p ?o } };
 * INSERT DATA {
 *   GRAPH IDENTIFIER { ... }
 *   GRAPH IDENTIFIER?ext=acl { ... }
 *   GRAPH trellis:PreferServerManaged { ... }
 *   GRAPH IDENTIFIER?ext=audit { ... }
 * }
 * </code></pre></p>
 */
private UpdateRequest buildUpdateRequest(final IRI identifier, final Literal time, final Dataset dataset,
        final OperationType type) {

    // Set the time
    dataset.add(PreferServerManaged, identifier, DC.modified, time);

    final UpdateRequest req = new UpdateRequest();
    req.add(new UpdateDeleteWhere(
            new QuadAcc(singletonList(new Quad(rdf.asJenaNode(identifier), SUBJECT, PREDICATE, OBJECT)))));
    req.add(new UpdateDeleteWhere(
            new QuadAcc(singletonList(new Quad(getAclIRI(identifier), SUBJECT, PREDICATE, OBJECT)))));
    req.add(new UpdateDeleteWhere(new QuadAcc(asList(
            new Quad(rdf.asJenaNode(PreferServerManaged), rdf.asJenaNode(identifier), rdf.asJenaNode(RDF.type),
                    rdf.asJenaNode(LDP.NonRDFSource)),
            new Quad(rdf.asJenaNode(PreferServerManaged), rdf.asJenaNode(identifier),
                    rdf.asJenaNode(DC.hasPart), SUBJECT),
            new Quad(rdf.asJenaNode(PreferServerManaged), SUBJECT, PREDICATE, OBJECT)))));
    req.add(new UpdateDeleteWhere(new QuadAcc(singletonList(
            new Quad(rdf.asJenaNode(PreferServerManaged), rdf.asJenaNode(identifier), PREDICATE, OBJECT)))));

    final QuadDataAcc sink = new QuadDataAcc(synchronizedList(new ArrayList<>()));
    if (type == OperationType.DELETE) {
        dataset.stream().filter(q -> q.getGraphName().filter(PreferServerManaged::equals).isPresent())
                .map(rdf::asJenaQuad).forEach(sink::addQuad);
    } else {
        dataset.stream().filter(q -> q.getGraphName().filter(PreferServerManaged::equals).isPresent())
                .map(rdf::asJenaQuad).forEach(sink::addQuad);
        dataset.getGraph(PreferUserManaged).ifPresent(g -> g.stream()
                .map(t -> new Quad(rdf.asJenaNode(identifier), rdf.asJenaTriple(t))).forEach(sink::addQuad));
        dataset.getGraph(PreferAccessControl).ifPresent(g -> g.stream()
                .map(t -> new Quad(getAclIRI(identifier), rdf.asJenaTriple(t))).forEach(sink::addQuad));
        dataset.getGraph(PreferAudit).ifPresent(g -> g.stream()
                .map(t -> new Quad(getAuditIRI(identifier), rdf.asJenaTriple(t))).forEach(sink::addQuad));
    }
    req.add(new UpdateDataInsert(sink));

    return req;
}

---

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

@Test
public void testUpdateRoot() throws Exception {
    final Instant early = now();
    final TriplestoreResourceService svc = new TriplestoreResourceService(
            connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
    svc.initialize();/*from w  ww  .  j  av  a  2 s .c  om*/

    final Resource res1 = svc.get(root).toCompletableFuture().join();
    assertAll("Check resource", checkResource(res1, root, LDP.BasicContainer, early));
    assertAll("Check resource stream", checkResourceStream(res1, 0L, 5L, 0L, 0L, 0L));

    final Dataset data = rdf.createDataset();
    svc.get(root)
            .thenAccept(res -> res.stream()
                    .filter(q -> !q.getGraphName().filter(Trellis.PreferServerManaged::equals).isPresent())
                    .forEach(data::add))
            .toCompletableFuture().join();
    data.add(Trellis.PreferUserManaged, root, RDFS.label, rdf.createLiteral("Resource Label"));
    data.add(Trellis.PreferUserManaged, root, RDFS.seeAlso, rdf.createIRI("http://example.com"));
    data.add(Trellis.PreferUserManaged, root, LDP.inbox, rdf.createIRI("http://ldn.example.com/"));
    data.add(Trellis.PreferUserManaged, root, RDF.type, rdf.createLiteral("Some weird type"));
    data.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Update);

    final Instant later = meanwhile();

    assertDoesNotThrow(() -> svc.replace(builder(root).interactionModel(LDP.BasicContainer).build(), data)
            .toCompletableFuture().join(), "Unsuccessful replace operation!");
    final Resource res2 = svc.get(root).toCompletableFuture().join();
    assertAll("Check resource", checkResource(res2, root, LDP.BasicContainer, later));
    assertAll("Check resource stream", checkResourceStream(res2, 4L, 5L, 1L, 0L, 0L));
}

---

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

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

    final Dataset dataset = rdf.createDataset();
    final BlankNode bnode = rdf.createBlankNode();
    dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("title"));
    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.RDFSource).container(root).build(), dataset)
                    .toCompletableFuture(), svc.touch(root).toCompletableFuture()).join(),
            "Unsuccessful create operation!");

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

---

• «
• 1
• 2
• 3
• »