htsworkflow/util/test/test_rdfhelp.py

   1 import os
   2 import unittest
   3 import types
   4
   5
   6 from datetime import datetime
   7
   8 from htsworkflow.util.rdfhelp import \
   9      blankOrUri, \
  10      dump_model, \
  11      fromTypedNode, \
  12      get_model, \
  13      load_string_into_model, \
  14      rdfsNS, \
  15      toTypedNode, \
  16      simplifyUri, \
  17      sanitize_literal, \
  18      xsdNS
  19
  20 try:
  21     import RDF
  22
  23     class TestRDFHelp(unittest.TestCase):
  24         def test_from_none(self):
  25           self.failUnlessEqual(fromTypedNode(None), None)
  26
  27         def test_typed_node_boolean(self):
  28             node = toTypedNode(True)
  29             self.failUnlessEqual(node.literal_value['string'], u'1')
  30             self.failUnlessEqual(str(node.literal_value['datatype']),
  31                                  'http://www.w3.org/2001/XMLSchema#boolean')
  32
  33         def test_bad_boolean(self):
  34             node = RDF.Node(literal='bad', datatype=xsdNS['boolean'].uri)
  35             self.failUnlessRaises(ValueError, fromTypedNode, node)
  36
  37         def test_typed_node_string(self):
  38             node = toTypedNode('hello')
  39             self.failUnlessEqual(node.literal_value['string'], u'hello')
  40             self.failUnless(node.literal_value['datatype'] is None)
  41
  42         def test_typed_real_like(self):
  43             num = 3.14
  44             node = toTypedNode(num)
  45             self.failUnlessEqual(fromTypedNode(node), num)
  46
  47         def test_typed_integer(self):
  48             num = 3
  49             node = toTypedNode(num)
  50             self.failUnlessEqual(fromTypedNode(node), num)
  51             self.failUnlessEqual(type(fromTypedNode(node)), type(num))
  52
  53         def test_typed_node_string(self):
  54             s = "Argh matey"
  55             node = toTypedNode(s)
  56             self.failUnlessEqual(fromTypedNode(node), s)
  57             self.failUnlessEqual(type(fromTypedNode(node)), types.UnicodeType)
  58
  59         def test_blank_or_uri_blank(self):
  60             node = blankOrUri()
  61             self.failUnlessEqual(node.is_blank(), True)
  62
  63         def test_blank_or_uri_url(self):
  64             s = 'http://google.com'
  65             node = blankOrUri(s)
  66             self.failUnlessEqual(node.is_resource(), True)
  67             self.failUnlessEqual(str(node.uri), s)
  68
  69         def test_blank_or_uri_node(self):
  70             s = RDF.Node(RDF.Uri('http://google.com'))
  71             node = blankOrUri(s)
  72             self.failUnlessEqual(node.is_resource(), True)
  73             self.failUnlessEqual(node, s)
  74
  75         def test_unicode_node_roundtrip(self):
  76             literal = u'\u5927'
  77             roundtrip = fromTypedNode(toTypedNode(literal))
  78             self.failUnlessEqual(roundtrip, literal)
  79             self.failUnlessEqual(type(roundtrip), types.UnicodeType)
  80
  81         def test_datetime_no_microsecond(self):
  82             dateTimeType = xsdNS['dateTime'].uri
  83             short_isostamp = '2011-12-20T11:44:25'
  84             short_node = RDF.Node(literal=short_isostamp,
  85                                  datatype=dateTimeType)
  86             short_datetime = datetime(2011,12,20,11,44,25)
  87
  88             self.assertEqual(fromTypedNode(short_node), short_datetime)
  89             self.assertEqual(toTypedNode(short_datetime), short_node)
  90             self.assertEqual(fromTypedNode(toTypedNode(short_datetime)),
  91                              short_datetime)
  92
  93         def test_datetime_with_microsecond(self):
  94             dateTimeType = xsdNS['dateTime'].uri
  95             long_isostamp = '2011-12-20T11:44:25.081776'
  96             long_node = RDF.Node(literal=long_isostamp,
  97                                  datatype=dateTimeType)
  98             long_datetime = datetime(2011,12,20,11,44,25,81776)
  99
 100             self.assertEqual(fromTypedNode(long_node), long_datetime)
 101             self.assertEqual(toTypedNode(long_datetime), long_node)
 102             self.assertEqual(fromTypedNode(toTypedNode(long_datetime)),
 103                              long_datetime)
 104
 105         def test_simplify_uri(self):
 106             nsOrg = RDF.NS('example.org/example#')
 107             nsCom = RDF.NS('example.com/example#')
 108
 109             term = 'foo'
 110             node = nsOrg[term]
 111             self.failUnlessEqual(simplifyUri(nsOrg, node), term)
 112             self.failUnlessEqual(simplifyUri(nsCom, node), None)
 113             self.failUnlessEqual(simplifyUri(nsOrg, node.uri), term)
 114
 115         def test_simplify_uri_exceptions(self):
 116             nsOrg = RDF.NS('example.org/example#')
 117             nsCom = RDF.NS('example.com/example#')
 118
 119             node = toTypedNode('bad')
 120             self.failUnlessRaises(ValueError, simplifyUri, nsOrg, node)
 121             self.failUnlessRaises(ValueError, simplifyUri, nsOrg, nsOrg)
 122
 123         def test_owl_import(self):
 124             path, name = os.path.split(__file__)
 125             loc = 'file://'+os.path.abspath(path)+'/'
 126             model = get_model()
 127             fragment = '''
 128 @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 129 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
 130 @prefix owl: <http://www.w3.org/2002/07/owl#> .
 131
 132 _:a owl:imports "{loc}extra.turtle" .
 133 '''.format(loc=loc)
 134             load_string_into_model(model, 'turtle', fragment, loc)
 135             tc = RDF.Node(RDF.Uri('http://jumpgate.caltech.edu/wiki/TestCase'))
 136             query = RDF.Statement(tc, rdfsNS['label'], None)
 137             result = list(model.find_statements(query))
 138             self.failUnlessEqual(len(result), 1)
 139             self.failUnlessEqual(str(result[0].object), 'TestCase')
 140
 141         def test_sanitize_literal_text(self):
 142             self.failUnlessRaises(ValueError, sanitize_literal, "hi")
 143             hello_text = "hello"
 144             hello_none = RDF.Node(hello_text)
 145             self.failUnlessEqual(str(sanitize_literal(hello_none)),
 146                                  hello_text)
 147             hello_str = RDF.Node(literal=hello_text,
 148                                  datatype=xsdNS['string'].uri)
 149             hello_clean = sanitize_literal(hello_str)
 150             self.failUnlessEqual(hello_clean.literal_value['string'],
 151                                  hello_text)
 152
 153         def test_sanitize_literal_html(self):
 154             hello = "hello <a onload='javascript:alert(\"foo\");' href='http://google.com'>google.com</a>, whats up?"
 155             hello_clean = 'hello <a href="http://google.com">google.com</a>, whats up?'
 156             hello_node = RDF.Node(literal=hello,
 157                                   datatype=xsdNS['string'].uri)
 158             hello_sanitized = sanitize_literal(hello_node)
 159             self.failUnlessEqual(hello_sanitized.literal_value['string'],
 160                                  hello_clean)
 161
 162             hostile = "hi <b>there</b><script type='text/javascript>alert('boo');</script><a href='javascript:alert('poke')>evil</a> scammer"
 163             hostile_node = RDF.Node(hostile)
 164             hostile_sanitized = sanitize_literal(hostile_node)
 165             # so it drops the stuff after the javascript link.
 166             # I suppose it could be worse
 167             hostile_result = """hi <b>there</b>"""
 168             self.failUnlessEqual(str(hostile_sanitized), hostile_result)
 169
 170
 171     def suite():
 172         return unittest.makeSuite(TestRDFHelp, 'test')
 173 except ImportError, e:
 174     print "Unable to test rdfhelp"
 175
 176     def suite():
 177         return None
 178
 179 if __name__ == "__main__":
 180     unittest.main(defaultTest='suite')