[test/RDFWriter] Add subClassOf tests

Author: mpsonntag

test/test_rdf_writer.py

@@ -4,13 +4,16 @@
 
 import yaml
 
+from owlrl import DeductiveClosure, RDFS_Semantics
+
 from rdflib import URIRef, Literal
-from rdflib.namespace import XSD, RDF
+from rdflib.namespace import Namespace, RDF, RDFS, XSD
+from rdflib.plugins.sparql import prepareQuery
 
 import odml
 
 from odml.format import Format
-from odml.tools.rdf_converter import RDFWriter
+from odml.tools.rdf_converter import ODML_NS, RDFWriter
 
 from .test_samplefile import SampleFileCreator
 from .test_samplefile import parse
@@ -312,6 +315,11 @@ def test_rdf_subclassing_switch(self):
         self.assertNotIn("odml:Cell", result)
 
     def test_rdf_custom_subclasses(self):
+        """
+        Test collection of the odml RDF subclassing feature.
+        Tests that the resulting output RDF document contains any required
+        additional RDF subclasses.
+        """
         sub_class_term = "cell"
 
         # Create minimal document
@@ -354,3 +362,157 @@ def test_rdf_custom_subclasses(self):
             rdf_writer = RDFWriter([doc], custom_subclasses=custom_class_dict)
             self.assertNotIn("odml:Cell", rdf_writer.get_rdf_str())
             self.assertIn("odml:Neuron", rdf_writer.get_rdf_str())
+
+    def test_rdf_subclassing_definitions(self):
+        """
+        Test that RDF Subclass definitions are written to the resulting graph.
+        """
+        # -- Test default subclassing
+        doc = odml.Document()
+        _ = odml.Section(name="test_subclassing", type="cell", parent=doc)
+
+        rdf_writer = RDFWriter([doc])
+        curr_str = " ".join(rdf_writer.get_rdf_str().split())
+        self.assertIn("odml:Cell a rdfs:Class ; rdfs:subClassOf odml:Section", curr_str)
+        self.assertIn("odml:Section a rdfs:Class", curr_str)
+
+        # -- Test multiple entries; a definition should only occur once in an RDF document
+        doc = odml.Document()
+        sec = odml.Section(name="test_subclassing", type="cell", parent=doc)
+        sub_sec = odml.Section(name="test_subclassing", type="cell", parent=sec)
+        _ = odml.Section(name="test_subclassing", type="cell", parent=sub_sec)
+
+        rdf_writer = RDFWriter([doc])
+        curr_str = " ".join(rdf_writer.get_rdf_str().split())
+        self.assertIn("odml:Cell a rdfs:Class ; rdfs:subClassOf odml:Section", curr_str)
+        self.assertIs(curr_str.count("odml:Cell a rdfs:Class ; rdfs:subClassOf odml:Section"), 1)
+        self.assertIn("odml:Section a rdfs:Class", curr_str)
+        self.assertIs(curr_str.count("odml:Section a rdfs:Class"), 1)
+
+        # -- Test custom subclassing
+        type_custom_class = "species"
+        custom_class_dict = {type_custom_class: "Species"}
+
+        doc = odml.Document()
+        _ = odml.Section(name="test_subclassing", type="cell", parent=doc)
+        _ = odml.Section(name="test_custom_subclassing", type=type_custom_class, parent=doc)
+
+        rdf_writer = RDFWriter([doc], custom_subclasses=custom_class_dict)
+        curr_str = " ".join(rdf_writer.get_rdf_str().split())
+        self.assertIn("odml:Cell a rdfs:Class ; rdfs:subClassOf odml:Section", curr_str)
+        self.assertIn("odml:Species a rdfs:Class ; rdfs:subClassOf odml:Section", curr_str)
+        self.assertIn("odml:Section a rdfs:Class", curr_str)
+
+        # -- Test inactive subclassing
+        doc = odml.Document()
+        _ = odml.Section(name="test_subclassing", type="cell", parent=doc)
+
+        rdf_writer = RDFWriter([doc], rdf_subclassing=False)
+        curr_str = " ".join(rdf_writer.get_rdf_str().split())
+        self.assertNotIn("odml:Section a rdfs:Class", curr_str)
+        self.assertNotIn("odml:Cell a rdfs:Class ; rdfs:subClassOf odml:Section", curr_str)
+
+    def test_rdf_subclassing_queries(self):
+        """
+        Test the proper implementation of the RDF subclassing feature. Tests ensure, that queries
+        relying on RDF Subclasses return appropriate results.
+        """
+        namespace_map = {"odml": Namespace(ODML_NS), "rdf": RDF, "rdfs": RDFS}
+
+        doc = odml.Document()
+        _ = odml.Section(name="test_subclass", type="cell", parent=doc)
+        _ = odml.Section(name="test_regular_class", type="regular", parent=doc)
+
+        rdf_writer = RDFWriter([doc])
+        _ = rdf_writer.get_rdf_str()
+
+        use_graph = rdf_writer.graph
+        DeductiveClosure(RDFS_Semantics).expand(use_graph)
+
+        q_string = "SELECT * WHERE {?s rdf:type odml:Section .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        # Make sure the query finds two sections
+        self.assertIs(len(use_graph.query(curr_query)), 2)
+
+        # Make sure the query finds
+        result_section = []
+        for row in use_graph.query(curr_query):
+            result_section.append(row.s)
+
+        q_string = "SELECT * WHERE {?s rdf:type odml:Cell .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        self.assertIs(len(use_graph.query(curr_query)), 1)
+        for row in use_graph.query(curr_query):
+            self.assertIn(row.s, result_section)
+
+        # -- Test custom subclassing queries
+        type_custom_class = "species"
+        type_overwrite_class = "cell"
+        custom_class_dict = {type_custom_class: "Species", type_overwrite_class: "Neuron"}
+
+        doc = odml.Document()
+        sec = odml.Section(name="test_subclass", type="species", parent=doc)
+        _ = odml.Section(name="test_subclass_overwrite", type="cell", parent=sec)
+        _ = odml.Section(name="test_regular_class", type="regular", parent=sec)
+
+        rdf_writer = RDFWriter([doc], custom_subclasses=custom_class_dict)
+        _ = rdf_writer.get_rdf_str()
+
+        use_graph = rdf_writer.graph
+        DeductiveClosure(RDFS_Semantics).expand(use_graph)
+
+        q_string = "SELECT * WHERE {?s rdf:type odml:Section .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        # Make sure the query finds three sections
+        self.assertIs(len(use_graph.query(curr_query)), 3)
+
+        # Make sure the query finds
+        result_section = []
+        for row in use_graph.query(curr_query):
+            result_section.append(row.s)
+
+        # Custom class 'Species' should be found.
+        q_string = "SELECT * WHERE {?s rdf:type odml:Species .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        self.assertIs(len(use_graph.query(curr_query)), 1)
+        for row in use_graph.query(curr_query):
+            self.assertIn(row.s, result_section)
+
+        # Custom class 'Neuron' should be found.
+        q_string = "SELECT * WHERE {?s rdf:type odml:Neuron .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        self.assertIs(len(use_graph.query(curr_query)), 1)
+        for row in use_graph.query(curr_query):
+            self.assertIn(row.s, result_section)
+
+        # Default class 'Cell' was replaced and should not return any result.
+        q_string = "SELECT * WHERE {?s rdf:type odml:Cell .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        self.assertIs(len(use_graph.query(curr_query)), 0)
+
+        # -- Test inactivated subclassing
+        doc = odml.Document()
+        _ = odml.Section(name="test_regular_class", type="regular", parent=doc)
+        _ = odml.Section(name="test_subclass", type="cell", parent=doc)
+
+        rdf_writer = RDFWriter([doc], rdf_subclassing=False)
+        _ = rdf_writer.get_rdf_str()
+
+        use_graph = rdf_writer.graph
+        DeductiveClosure(RDFS_Semantics).expand(use_graph)
+
+        q_string = "SELECT * WHERE {?s rdf:type odml:Section .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        self.assertIs(len(use_graph.query(curr_query)), 2)
+
+        q_string = "SELECT * WHERE {?s rdf:type odml:Cell .}"
+        curr_query = prepareQuery(q_string, initNs=namespace_map)
+
+        self.assertIs(len(use_graph.query(curr_query)), 0)