htsworkflow/util/test/test_rdfhelp.py

   1 from __future__ import print_function
   2
   3 import os
   4 import types
   5 from unittest import TestCase
   6 from datetime import datetime
   7 import six
   8
   9 from htsworkflow.util.rdfhelp import \
  10      add_default_schemas, \
  11      blankOrUri, \
  12      dcNS, \
  13      dump_model, \
  14      fromTypedNode, \
  15      get_model, \
  16      guess_parser, \
  17      guess_parser_by_extension, \
  18      load_string_into_model, \
  19      owlNS, \
  20      rdfNS, \
  21      rdfsNS, \
  22      remove_schemas, \
  23      toTypedNode, \
  24      strip_namespace, \
  25      simplify_uri, \
  26      sanitize_literal, \
  27      xsdNS
  28
  29 try:
  30     import RDF
  31
  32     class TestRDFHelp(TestCase):
  33         def test_from_none(self):
  34           self.assertEqual(fromTypedNode(None), None)
  35
  36         def test_typed_node_boolean(self):
  37             node = toTypedNode(True)
  38             self.assertIn(node.literal_value['string'], (u'1', u'true'))
  39             self.assertEqual(str(node.literal_value['datatype']),
  40                                  'http://www.w3.org/2001/XMLSchema#boolean')
  41
  42         def test_bad_boolean(self):
  43             node = RDF.Node(literal='bad', datatype=xsdNS['boolean'].uri)
  44             # older versions of librdf ~< 1.0.16 left the literal
  45             # alone. and thus should fail the fromTypedNode call
  46             # newer versions coerced the odd value to false.
  47             try:
  48                 self.assertFalse(fromTypedNode(node))
  49             except ValueError as e:
  50                 pass
  51
  52         def test_typed_node_string_node_attributes(self):
  53             node = toTypedNode('hello')
  54             self.assertEqual(node.literal_value['string'], u'hello')
  55             self.assertTrue(node.literal_value['datatype'] is None)
  56
  57         def test_typed_real_like(self):
  58             num = 3.14
  59             node = toTypedNode(num)
  60             self.assertEqual(fromTypedNode(node), num)
  61
  62         def test_typed_integer(self):
  63             num = 3
  64             node = toTypedNode(num)
  65             self.assertEqual(fromTypedNode(node), num)
  66             self.assertEqual(type(fromTypedNode(node)), type(num))
  67
  68         def test_typed_node_string(self):
  69             s = "Argh matey"
  70             node = toTypedNode(s)
  71             self.assertEqual(fromTypedNode(node), s)
  72             self.assertTrue(isinstance(fromTypedNode(node), six.text_type))
  73
  74         def test_blank_or_uri_blank(self):
  75             node = blankOrUri()
  76             self.assertEqual(node.is_blank(), True)
  77
  78         def test_blank_or_uri_url(self):
  79             s = 'http://google.com'
  80             node = blankOrUri(s)
  81             self.assertEqual(node.is_resource(), True)
  82             self.assertEqual(str(node.uri), s)
  83
  84         def test_blank_or_uri_node(self):
  85             s = RDF.Node(RDF.Uri('http://google.com'))
  86             node = blankOrUri(s)
  87             self.assertEqual(node.is_resource(), True)
  88             self.assertEqual(node, s)
  89
  90         def test_unicode_node_roundtrip(self):
  91             literal = u'\u5927'
  92             roundtrip = fromTypedNode(toTypedNode(literal))
  93             self.assertTrue(isinstance(roundtrip, six.text_type))
  94
  95         def test_datetime_no_microsecond(self):
  96             dateTimeType = xsdNS['dateTime'].uri
  97             short_isostamp = '2011-12-20T11:44:25'
  98             short_node = RDF.Node(literal=short_isostamp,
  99                                  datatype=dateTimeType)
 100             short_datetime = datetime(2011,12,20,11,44,25)
 101
 102             self.assertEqual(fromTypedNode(short_node), short_datetime)
 103             self.assertEqual(toTypedNode(short_datetime), short_node)
 104             self.assertEqual(fromTypedNode(toTypedNode(short_datetime)),
 105                              short_datetime)
 106
 107         def test_datetime_with_microsecond(self):
 108             dateTimeType = xsdNS['dateTime'].uri
 109             long_isostamp = '2011-12-20T11:44:25.081776'
 110             long_node = RDF.Node(literal=long_isostamp,
 111                                  datatype=dateTimeType)
 112             long_datetime = datetime(2011,12,20,11,44,25,81776)
 113
 114             self.assertEqual(fromTypedNode(long_node), long_datetime)
 115             self.assertEqual(toTypedNode(long_datetime), long_node)
 116             self.assertEqual(fromTypedNode(toTypedNode(long_datetime)),
 117                              long_datetime)
 118
 119         def test_strip_namespace_uri(self):
 120             nsOrg = RDF.NS('example.org/example#')
 121             nsCom = RDF.NS('example.com/example#')
 122
 123             term = 'foo'
 124             node = nsOrg[term]
 125             self.assertEqual(strip_namespace(nsOrg, node), term)
 126             self.assertEqual(strip_namespace(nsCom, node), None)
 127             self.assertEqual(strip_namespace(nsOrg, node.uri), term)
 128
 129         def test_strip_namespace_exceptions(self):
 130             nsOrg = RDF.NS('example.org/example#')
 131             nsCom = RDF.NS('example.com/example#')
 132
 133             node = toTypedNode('bad')
 134             self.assertRaises(ValueError, strip_namespace, nsOrg, node)
 135             self.assertRaises(ValueError, strip_namespace, nsOrg, nsOrg)
 136
 137         def test_simplify_uri(self):
 138             DATA = [('http://asdf.org/foo/bar', 'bar'),
 139                     ('http://asdf.org/foo/bar#bleem', 'bleem'),
 140                     ('http://asdf.org/foo/bar/', 'bar'),
 141                     ('http://asdf.org/foo/bar?was=foo', 'was=foo')]
 142
 143             for uri, expected in DATA:
 144                 self.assertEqual(simplify_uri(uri), expected)
 145
 146             for uri, expected in DATA:
 147                 n = RDF.Uri(uri)
 148                 self.assertEqual(simplify_uri(n), expected)
 149
 150             for uri, expected in DATA:
 151                 n = RDF.Node(RDF.Uri(uri))
 152                 self.assertEqual(simplify_uri(n), expected)
 153
 154             # decoding literals is questionable
 155             n = toTypedNode('http://foo/bar')
 156             self.assertRaises(ValueError, simplify_uri, n)
 157
 158         def test_owl_import(self):
 159             path, name = os.path.split(__file__)
 160             #loc = 'file://'+os.path.abspath(path)+'/'
 161             loc = os.path.abspath(path)+'/'
 162             model = get_model()
 163             fragment = '''
 164 @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 165 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
 166 @prefix owl: <http://www.w3.org/2002/07/owl#> .
 167
 168 _:a owl:imports "{loc}extra.turtle" .
 169 '''.format(loc=loc)
 170             load_string_into_model(model, 'turtle', fragment, loc)
 171             tc = RDF.Node(RDF.Uri('http://jumpgate.caltech.edu/wiki/TestCase'))
 172             query = RDF.Statement(tc, rdfsNS['label'], None)
 173             result = list(model.find_statements(query))
 174             self.assertEqual(len(result), 1)
 175             self.assertEqual(str(result[0].object), 'TestCase')
 176
 177         def test_sanitize_literal_text(self):
 178             self.assertRaises(ValueError, sanitize_literal, "hi")
 179             hello_text = "hello"
 180             hello_none = RDF.Node(hello_text)
 181             self.assertEqual(str(sanitize_literal(hello_none)),
 182                                  hello_text)
 183             hello_str = RDF.Node(literal=hello_text,
 184                                  datatype=xsdNS['string'].uri)
 185             hello_clean = sanitize_literal(hello_str)
 186             self.assertEqual(hello_clean.literal_value['string'],
 187                                  hello_text)
 188
 189         def test_sanitize_literal_empty_string(self):
 190             value = ""
 191             value_node = RDF.Node(value)
 192             self.assertEqual(str(sanitize_literal(value_node)), value)
 193
 194         def test_sanitize_literal_html(self):
 195             hello = "hello <a onload='javascript:alert(\"foo\");' href='http://google.com'>google.com</a>, whats up?"
 196             hello_clean = 'hello <a href="http://google.com">google.com</a>, whats up?'
 197             hello_node = RDF.Node(literal=hello,
 198                                   datatype=xsdNS['string'].uri)
 199             hello_sanitized = sanitize_literal(hello_node)
 200             self.assertEqual(hello_sanitized.literal_value['string'],
 201                                  hello_clean)
 202
 203             hostile = "hi <b>there</b><script type='text/javascript>alert('boo');</script><a href='javascript:alert('poke')>evil</a> scammer"
 204             hostile_node = RDF.Node(hostile)
 205             hostile_sanitized = sanitize_literal(hostile_node)
 206             # so it drops the stuff after the javascript link.
 207             # I suppose it could be worse
 208             hostile_result = """hi <b>there</b>"""
 209             self.assertEqual(str(hostile_sanitized), hostile_result)
 210
 211         def test_guess_parser_from_file(self):
 212             DATA = [
 213                 ('/a/b/c.rdf', 'rdfxml'),
 214                 ('/a/b/c.xml', 'rdfxml'),
 215                 ('/a/b/c.html', 'rdfa'),
 216                 ('/a/b/c.turtle', 'turtle'),
 217                 ('http://foo.bar/bleem.turtle', 'turtle')]
 218             for path, parser in DATA:
 219                 self.assertEqual(guess_parser_by_extension(path), parser)
 220                 self.assertEqual(guess_parser(None, path), parser)
 221
 222             DATA = [
 223                 ('application/rdf+xml', 'http://a.org/b/c', 'rdfxml'),
 224                 ('application/x-turtle', 'http://a.org/b/c', 'turtle'),
 225                 ('text/html', 'http://a.org/b/c', 'rdfa'),
 226                 ('text/html', 'http://a.org/b/c.html', 'rdfa'),
 227                 ('text/plain', 'http://a.org/b/c.turtle', 'turtle'),
 228                 ('text/plain', 'http://a.org/b/c', 'guess')
 229             ]
 230             for contenttype, url, parser in DATA:
 231                 self.assertEqual(guess_parser(contenttype, url), parser)
 232
 233     class TestRDFSchemas(TestCase):
 234         def test_rdf_schema(self):
 235             """Does it basically work?
 236             """
 237             model = get_model()
 238             self.assertEqual(model.size(), 0)
 239             add_default_schemas(model)
 240             self.assertTrue(model.size() > 0)
 241             remove_schemas(model)
 242             self.assertEqual(model.size(), 0)
 243
 244         def test_included_schemas(self):
 245             model = get_model()
 246             add_default_schemas(model)
 247
 248             # rdf test
 249             s = RDF.Statement(rdfNS[''], dcNS['title'], None)
 250             title = model.get_target(rdfNS[''], dcNS['title'])
 251             self.assertTrue(title is not None)
 252
 253             s = RDF.Statement(rdfNS['Property'], rdfNS['type'], rdfsNS['Class'])
 254             self.assertTrue(model.contains_statement(s))
 255
 256             # rdfs test
 257             s = RDF.Statement(rdfsNS['Class'], rdfNS['type'], rdfsNS['Class'])
 258             self.assertTrue(model.contains_statement(s))
 259
 260             s = RDF.Statement(owlNS['inverseOf'], rdfNS['type'],
 261                               rdfNS['Property'])
 262             self.assertTrue(model.contains_statement(s))
 263
 264
 265 except ImportError as e:
 266     print("Unable to test rdfhelp")
 267
 268 def suite():
 269     from unittest import TestSuite, defaultTestLoader
 270     suite = TestSuite()
 271     suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFHelp))
 272     suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFSchemas))
 273     return suite
 274
 275
 276 if __name__ == "__main__":
 277     from unittest import main
 278     main(defaultTest="suite")