You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@clerezza.apache.org by ha...@apache.org on 2019/02/10 15:17:22 UTC
[clerezza] branch reunited updated: CLEREZZA-1031: Move
TcProviderTest from test.utils to dataset
This is an automated email from the ASF dual-hosted git repository.
hasan pushed a commit to branch reunited
in repository https://gitbox.apache.org/repos/asf/clerezza.git
The following commit(s) were added to refs/heads/reunited by this push:
new cfc3226 CLEREZZA-1031: Move TcProviderTest from test.utils to dataset
cfc3226 is described below
commit cfc3226cc7eea48b7688227335d884863db32513
Author: Hasan <ha...@apache.org>
AuthorDate: Sun Feb 10 16:16:52 2019 +0100
CLEREZZA-1031: Move TcProviderTest from test.utils to dataset
---
.../dataset/test/utils/TcProviderTest.java | 480 +++++++++++++++++++++
.../simple/storage/GenericTcProviderTest.java | 2 +-
2 files changed, 481 insertions(+), 1 deletion(-)
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/test/utils/TcProviderTest.java b/dataset/src/test/java/org/apache/clerezza/dataset/test/utils/TcProviderTest.java
new file mode 100644
index 0000000..d319e5d
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/test/utils/TcProviderTest.java
@@ -0,0 +1,480 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the License.
+ */
+
+package org.apache.clerezza.dataset.test.utils;
+
+import org.apache.clerezza.api.*;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.graph.SimpleGraph;
+import org.apache.clerezza.dataset.EntityAlreadyExistsException;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.TcProvider;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author mir,rbn
+ */
+public abstract class TcProviderTest {
+
+ protected final IRI uriRefA = generateUri("a");
+ protected final IRI uriRefA1 = generateUri("a1");
+ protected final IRI uriRefB = generateUri("b");
+ protected final IRI uriRefB1 = generateUri("b1");
+ protected final IRI uriRefC = generateUri("c");
+
+ protected final IRI graphIRI = generateUri("myGraph");
+ protected final IRI otherGraphIRI = new IRI(graphIRI.getUnicodeString());
+
+ @Test
+ public void testCreateImmutableGraph() {
+ TcProvider simpleTcmProvider = getInstance();
+ Graph mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefA, uriRefA, uriRefA));
+
+ ImmutableGraph createdGraph = simpleTcmProvider.createImmutableGraph(uriRefA, mGraph);
+
+ Iterator<Triple> iteratorInput = mGraph.iterator();
+ Iterator<Triple> iteratorCreated = createdGraph.iterator();
+ Assert.assertEquals(iteratorInput.next(), iteratorCreated.next());
+ Assert.assertFalse(iteratorCreated.hasNext());
+
+ try {
+ simpleTcmProvider.createImmutableGraph(uriRefA, mGraph);
+ Assert.assertTrue(false);
+ } catch (EntityAlreadyExistsException e) {
+ Assert.assertTrue(true);
+ }
+ simpleTcmProvider.deleteGraph(uriRefA);
+ }
+
+ @Test
+ public void testCreateGraph() {
+ TcProvider simpleTcmProvider = getInstance();
+ Graph mGraph = simpleTcmProvider.createGraph(uriRefA);
+ Assert.assertTrue(mGraph.isEmpty());
+
+ try {
+ simpleTcmProvider.createGraph(uriRefA);
+ Assert.assertTrue(false);
+ } catch (EntityAlreadyExistsException e) {
+ Assert.assertTrue(true);
+ }
+ simpleTcmProvider.deleteGraph(uriRefA);
+ }
+
+ @Test
+ public void testGetImmutableGraph() {
+ TcProvider simpleTcmProvider = getInstance();
+ // add Graphs
+ Graph mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefA, uriRefA, uriRefA));
+ simpleTcmProvider.createImmutableGraph(uriRefA, mGraph);
+ mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefA1, uriRefA1, uriRefA1));
+ simpleTcmProvider.createImmutableGraph(uriRefA1, mGraph);
+ mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefB, uriRefB, uriRefB));
+ simpleTcmProvider.createImmutableGraph(uriRefB, mGraph);
+ mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefB1, uriRefB1, uriRefB1));
+ simpleTcmProvider.createImmutableGraph(uriRefB1, mGraph);
+
+ ImmutableGraph bGraph = simpleTcmProvider.getImmutableGraph(uriRefB);
+ Iterator<Triple> iterator = bGraph.iterator();
+ Assert.assertEquals(new TripleImpl(uriRefB, uriRefB, uriRefB), iterator.next());
+ Assert.assertFalse(iterator.hasNext());
+ simpleTcmProvider.deleteGraph(uriRefA);
+ simpleTcmProvider.deleteGraph(uriRefA1);
+ simpleTcmProvider.deleteGraph(uriRefB);
+ simpleTcmProvider.deleteGraph(uriRefB1);
+ }
+
+ @Test
+ public void testGetGraph() {
+ TcProvider simpleTcmProvider = getInstance();
+ // add Graphs
+ Graph mGraph = simpleTcmProvider.createGraph(uriRefA);
+ mGraph.add(new TripleImpl(uriRefA, uriRefA, uriRefA));
+ mGraph = simpleTcmProvider.createGraph(uriRefA1);
+ mGraph.add(new TripleImpl(uriRefA1, uriRefA1, uriRefA1));
+ mGraph = simpleTcmProvider.createGraph(uriRefB);
+ mGraph.add(new TripleImpl(uriRefB, uriRefB, uriRefA));
+ mGraph.add(new TripleImpl(uriRefB, uriRefB, uriRefB));
+ mGraph.remove(new TripleImpl(uriRefB, uriRefB, uriRefA));
+ Assert.assertEquals(1, mGraph.size());
+ mGraph = simpleTcmProvider.createGraph(uriRefB1);
+ mGraph.add(new TripleImpl(uriRefB1, uriRefB1, uriRefB1));
+
+ Graph bGraph = simpleTcmProvider.getGraph(uriRefB);
+ Iterator<Triple> iterator = bGraph.iterator();
+ Assert.assertEquals(new TripleImpl(uriRefB, uriRefB, uriRefB), iterator.next());
+ Assert.assertFalse(iterator.hasNext());
+ simpleTcmProvider.deleteGraph(uriRefA);
+ simpleTcmProvider.deleteGraph(uriRefA1);
+ simpleTcmProvider.deleteGraph(uriRefB);
+ simpleTcmProvider.deleteGraph(uriRefB1);
+
+ }
+
+ @Test
+ public void testGetTriples() {
+ TcProvider simpleTcmProvider = getInstance();
+ // add Graphs
+ Graph mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefA, uriRefA, uriRefA));
+ simpleTcmProvider.createImmutableGraph(uriRefA, mGraph);
+ mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefB, uriRefB, uriRefB));
+ simpleTcmProvider.createImmutableGraph(uriRefB, mGraph);
+ // add Graphs
+ mGraph = simpleTcmProvider.createGraph(uriRefA1);
+ mGraph.add(new TripleImpl(uriRefA1, uriRefA1, uriRefA1));
+ mGraph = simpleTcmProvider.createGraph(uriRefB1);
+ mGraph.add(new TripleImpl(uriRefB1, uriRefB1, uriRefB1));
+
+ // get a ImmutableGraph
+ Graph tripleCollection = simpleTcmProvider.getGraph(uriRefA);
+ // get a Graph
+ Graph tripleCollection2 = simpleTcmProvider.getGraph(uriRefB1);
+
+ Iterator<Triple> iterator = tripleCollection.iterator();
+ Assert.assertEquals(new TripleImpl(uriRefA, uriRefA, uriRefA), iterator.next());
+ Assert.assertFalse(iterator.hasNext());
+
+ iterator = tripleCollection2.iterator();
+ Assert.assertEquals(new TripleImpl(uriRefB1, uriRefB1, uriRefB1), iterator.next());
+ Assert.assertFalse(iterator.hasNext());
+ simpleTcmProvider.deleteGraph(uriRefA);
+ simpleTcmProvider.deleteGraph(uriRefA1);
+ simpleTcmProvider.deleteGraph(uriRefB);
+ simpleTcmProvider.deleteGraph(uriRefB1);
+ }
+
+ @Test
+ public void testDeleteEntity() {
+ TcProvider simpleTcmProvider = getInstance();
+ Graph mGraph = new SimpleGraph();
+ mGraph.add(new TripleImpl(uriRefA, uriRefA, uriRefA));
+ ImmutableGraph graph = mGraph.getImmutableGraph();
+ simpleTcmProvider.createImmutableGraph(uriRefA, graph);
+ simpleTcmProvider.createImmutableGraph(uriRefC, graph);
+
+ simpleTcmProvider.deleteGraph(uriRefA);
+ try {
+ simpleTcmProvider.getGraph(uriRefA);
+ Assert.assertTrue(false);
+ } catch (NoSuchEntityException e) {
+ Assert.assertTrue(true);
+ }
+
+ // Check that graph is still available under uriRefC
+ ImmutableGraph cGraph = simpleTcmProvider.getImmutableGraph(uriRefC);
+ Assert.assertNotNull(cGraph);
+ simpleTcmProvider.deleteGraph(uriRefC);
+ }
+
+ /**
+ * Subclasses implement this method to provide implementation instances of
+ * <code>TcProvider</code>. The first call within a test method has to
+ * return a empty TcProvider. Subsequent calls within the test method
+ * should instantiate a new provider, but load the previously added data from
+ * its "persistent" store.
+ *
+ * @return a TcProvider of the implementation to be tested.
+ */
+ protected abstract TcProvider getInstance();
+
+// @Test
+// public void testGetNames() {
+// Graph mGraph = new SimpleGraph();
+// mGraph.add(new TripleImpl(uriRefB, uriRefB, uriRefB));
+// simpleTcmProvider.createGraph(uriRefB, mGraph.getGraph());
+//
+// mGraph = new SimpleGraph();
+// mGraph.add(new TripleImpl(uriRefA, uriRefA, uriRefA));
+// ImmutableGraph graph = mGraph.getGraph();
+// simpleTcmProvider.createGraph(uriRefA, graph);
+// simpleTcmProvider.createGraph(uriRefC, graph);
+//
+// Set<IRI> names = simpleTcmProvider.getNames(graph);
+//
+// assertTrue(names.contains(uriRefA));
+// assertTrue(names.contains(uriRefC));
+// assertEquals(2, names.size());
+//
+// assertFalse(names.contains(uriRefB));
+// }
+
+ @Test
+ public void testCreateGraphExtended() throws Exception {
+
+ TcProvider provider = getInstance();
+ Graph graph = provider.createGraph(graphIRI);
+ Assert.assertNotNull(graph);
+ //get a new provider and check that graph is there
+ provider = getInstance();
+ graph = provider.getGraph(graphIRI);
+ Assert.assertNotNull(graph);
+ //check that there is no such graph, but only the mgraph
+ boolean expThrown = false;
+ try {
+ ImmutableGraph g = provider.getImmutableGraph(graphIRI);
+ } catch(NoSuchEntityException e) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+ provider.deleteGraph(graphIRI);
+ }
+
+ @Test
+ public void testCreateImmutableGraphExtended() throws Exception {
+
+ TcProvider provider = getInstance();
+ ImmutableGraph graph = provider.createImmutableGraph(graphIRI, null);
+
+ Assert.assertNotNull(graph);
+
+ //get a new provider and check that graph is there
+ provider = getInstance();
+ graph = provider.getImmutableGraph(graphIRI);
+ Assert.assertNotNull(graph);
+
+ //check that there is no such mgraph, but only the graph
+ boolean expThrown = false;
+
+ try {
+ Graph g = provider.getMGraph(graphIRI);
+ } catch(NoSuchEntityException e) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+ provider.deleteGraph(graphIRI);
+ }
+
+ @Test
+ public void testCreateGraphNoDuplicateNames() throws Exception {
+
+ TcProvider provider = getInstance();
+ ImmutableGraph graph = provider.createImmutableGraph(graphIRI, null);
+ Assert.assertNotNull(graph);
+ boolean expThrown = false;
+ try {
+ ImmutableGraph other = provider.createImmutableGraph(otherGraphIRI, null);
+ } catch(EntityAlreadyExistsException eaee) {
+ expThrown = true;
+ }
+ Assert.assertTrue(expThrown);
+ provider.deleteGraph(graphIRI);
+ }
+
+ @Test
+ public void testCreateGraphNoDuplicateNames2() throws Exception {
+
+ TcProvider provider = getInstance();
+ Graph graph = provider.createGraph(graphIRI);
+ Assert.assertNotNull(graph);
+ boolean expThrown = false;
+ try {
+ Graph other = provider.createGraph(otherGraphIRI);
+ } catch(EntityAlreadyExistsException eaee) {
+ expThrown = true;
+ }
+ Assert.assertTrue(expThrown);
+ provider.deleteGraph(graphIRI);
+ }
+
+ @Test
+ public void testCreateGraphWithInitialCollection() throws Exception {
+
+ Triple t1 = createTestTriple();
+
+ TcProvider provider = getInstance();
+
+ ImmutableGraph graph = provider.createImmutableGraph(graphIRI, createTestTripleCollection(t1));
+
+ Assert.assertEquals(1, graph.size());
+ Assert.assertTrue(graph.contains(t1));
+ provider.deleteGraph(graphIRI);
+ }
+
+ @Test
+ public void testGraphIsNotMutable() throws Exception {
+
+ Triple t1 = createTestTriple();
+ Set<Triple> t = new HashSet<Triple>();
+ t.add(t1);
+
+ TcProvider provider = getInstance();
+
+ ImmutableGraph graph = provider.createImmutableGraph(graphIRI, createTestTripleCollection(t1));
+
+ boolean expThrown = false;
+
+ try {
+ graph.add(t1);
+ } catch(UnsupportedOperationException uoe) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+ expThrown = false;
+
+ try {
+ graph.remove(t1);
+ } catch(UnsupportedOperationException uoe) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+ expThrown = false;
+
+ try {
+ graph.addAll(t);
+ } catch(UnsupportedOperationException uoe) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+
+ expThrown = false;
+
+ try {
+ graph.clear();
+ } catch(UnsupportedOperationException uoe) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+
+ expThrown = false;
+
+ try {
+ graph.removeAll(t);
+ } catch(UnsupportedOperationException uoe) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+ provider.deleteGraph(graphIRI);
+ }
+
+// This tests can not pass, because equals in AbstractGraph is not implemented
+// yet.
+// @Test
+// public void testGraphHasName() throws Exception {
+//
+// TcProvider provider = getInstance();
+//
+// Graph triples = createTestTripleCollection(createTestTriple());
+// ImmutableGraph graph = provider.createGraph(graphIRI, triples);
+//
+// provider = getInstance();
+// Set<IRI> names = provider.getNames(graph);
+// assertTrue(names.contains(graphIRI));
+// }
+//
+// @Test
+// public void testCreateSameGraphWithDifferentNames() throws Exception {
+//
+// Graph triples = createTestTripleCollection(createTestTriple());
+//
+// TcProvider provider = getInstance();
+// IRI name1 = new IRI("http://myGraph1");
+// ImmutableGraph graph = provider.createGraph(name1, triples);
+//
+// IRI name2 = new IRI("http://myGraph2");
+// ImmutableGraph secondGraph = provider.createGraph(name2, triples);
+//
+// Set<IRI> names = provider.getNames(graph);
+// assertNotNull(names);
+// assertEquals(2, names.size());
+// }
+
+ @Test
+ public void testGraphDeletion() throws Exception {
+
+ Graph triples = createTestTripleCollection(createTestTriple());
+
+ TcProvider provider = getInstance();
+ IRI name1 = new IRI("http://myGraph1");
+ ImmutableGraph graph = provider.createImmutableGraph(name1, triples);
+
+ IRI name2 = new IRI("http://myGraph2");
+ ImmutableGraph secondGraph = provider.createImmutableGraph(name2, triples);
+
+ //if we delete graph with name1, the second graph should still be there
+ provider.deleteGraph(name1);
+
+ provider = getInstance();
+ ImmutableGraph firstGraph = provider.getImmutableGraph(name2);
+ Assert.assertNotNull(firstGraph);
+
+ //check second name is not there
+ boolean expThrown = false;
+
+ try {
+ ImmutableGraph g = provider.getImmutableGraph(name1);
+ } catch(NoSuchEntityException nses) {
+ expThrown = true;
+ }
+
+ Assert.assertTrue(expThrown);
+ provider.deleteGraph(name2);
+ }
+
+
+
+ @Test
+ public void testGetTriplesGraph() throws Exception {
+ TcProvider provider = getInstance();
+
+ Graph graph = provider.createGraph(graphIRI);
+
+ Graph tc = provider.getGraph(graphIRI);
+ Assert.assertNotNull(tc);
+ provider.deleteGraph(graphIRI);
+ }
+
+ private Triple createTestTriple() {
+ BlankNodeOrIRI subject = new BlankNode() {};
+ IRI predicate = new IRI("http://test.com/");
+ BlankNodeOrIRI object = new IRI("http://test.com/myObject");
+ return new TripleImpl(subject, predicate, object);
+ }
+
+ private Graph createTestTripleCollection(Triple t) {
+ Set<Triple> ts = new HashSet<Triple>();
+ ts.add(t);
+ return new SimpleGraph(ts);
+ }
+
+ protected IRI generateUri(String name) {
+ return new IRI("http://example.org/" + name);
+ }
+
+}
diff --git a/dataset/src/test/java/org/apache/clerezza/simple/storage/GenericTcProviderTest.java b/dataset/src/test/java/org/apache/clerezza/simple/storage/GenericTcProviderTest.java
index 65dcd10..c46a835 100644
--- a/dataset/src/test/java/org/apache/clerezza/simple/storage/GenericTcProviderTest.java
+++ b/dataset/src/test/java/org/apache/clerezza/simple/storage/GenericTcProviderTest.java
@@ -19,7 +19,7 @@
package org.apache.clerezza.simple.storage;
import org.apache.clerezza.dataset.TcProvider;
-import org.apache.clerezza.test.utils.TcProviderTest;
+import org.apache.clerezza.dataset.test.utils.TcProviderTest;
import org.junit.After;
/**