3 from unittest2 import TestCase
5 from datetime import datetime
7 from htsworkflow.util.rdfhelp import \
15 guess_parser_by_extension, \
16 load_string_into_model, \
30 class TestRDFHelp(TestCase):
31 def test_from_none(self):
32 self.failUnlessEqual(fromTypedNode(None), None)
34 def test_typed_node_boolean(self):
35 node = toTypedNode(True)
36 self.failUnlessEqual(node.literal_value['string'], u'1')
37 self.failUnlessEqual(str(node.literal_value['datatype']),
38 'http://www.w3.org/2001/XMLSchema#boolean')
40 def test_bad_boolean(self):
41 node = RDF.Node(literal='bad', datatype=xsdNS['boolean'].uri)
42 self.failUnlessRaises(ValueError, fromTypedNode, node)
44 def test_typed_node_string(self):
45 node = toTypedNode('hello')
46 self.failUnlessEqual(node.literal_value['string'], u'hello')
47 self.failUnless(node.literal_value['datatype'] is None)
49 def test_typed_real_like(self):
51 node = toTypedNode(num)
52 self.failUnlessEqual(fromTypedNode(node), num)
54 def test_typed_integer(self):
56 node = toTypedNode(num)
57 self.failUnlessEqual(fromTypedNode(node), num)
58 self.failUnlessEqual(type(fromTypedNode(node)), type(num))
60 def test_typed_node_string(self):
63 self.failUnlessEqual(fromTypedNode(node), s)
64 self.failUnlessEqual(type(fromTypedNode(node)), types.UnicodeType)
66 def test_blank_or_uri_blank(self):
68 self.failUnlessEqual(node.is_blank(), True)
70 def test_blank_or_uri_url(self):
71 s = 'http://google.com'
73 self.failUnlessEqual(node.is_resource(), True)
74 self.failUnlessEqual(str(node.uri), s)
76 def test_blank_or_uri_node(self):
77 s = RDF.Node(RDF.Uri('http://google.com'))
79 self.failUnlessEqual(node.is_resource(), True)
80 self.failUnlessEqual(node, s)
82 def test_unicode_node_roundtrip(self):
84 roundtrip = fromTypedNode(toTypedNode(literal))
85 self.failUnlessEqual(roundtrip, literal)
86 self.failUnlessEqual(type(roundtrip), types.UnicodeType)
88 def test_datetime_no_microsecond(self):
89 dateTimeType = xsdNS['dateTime'].uri
90 short_isostamp = '2011-12-20T11:44:25'
91 short_node = RDF.Node(literal=short_isostamp,
92 datatype=dateTimeType)
93 short_datetime = datetime(2011,12,20,11,44,25)
95 self.assertEqual(fromTypedNode(short_node), short_datetime)
96 self.assertEqual(toTypedNode(short_datetime), short_node)
97 self.assertEqual(fromTypedNode(toTypedNode(short_datetime)),
100 def test_datetime_with_microsecond(self):
101 dateTimeType = xsdNS['dateTime'].uri
102 long_isostamp = '2011-12-20T11:44:25.081776'
103 long_node = RDF.Node(literal=long_isostamp,
104 datatype=dateTimeType)
105 long_datetime = datetime(2011,12,20,11,44,25,81776)
107 self.assertEqual(fromTypedNode(long_node), long_datetime)
108 self.assertEqual(toTypedNode(long_datetime), long_node)
109 self.assertEqual(fromTypedNode(toTypedNode(long_datetime)),
112 def test_strip_namespace_uri(self):
113 nsOrg = RDF.NS('example.org/example#')
114 nsCom = RDF.NS('example.com/example#')
118 self.failUnlessEqual(stripNamespace(nsOrg, node), term)
119 self.failUnlessEqual(stripNamespace(nsCom, node), None)
120 self.failUnlessEqual(stripNamespace(nsOrg, node.uri), term)
122 def test_strip_namespace_exceptions(self):
123 nsOrg = RDF.NS('example.org/example#')
124 nsCom = RDF.NS('example.com/example#')
126 node = toTypedNode('bad')
127 self.failUnlessRaises(ValueError, stripNamespace, nsOrg, node)
128 self.failUnlessRaises(ValueError, stripNamespace, nsOrg, nsOrg)
130 def test_simplify_uri(self):
131 DATA = [('http://asdf.org/foo/bar', 'bar'),
132 ('http://asdf.org/foo/bar#bleem', 'bleem'),
133 ('http://asdf.org/foo/bar/', 'bar'),
134 ('http://asdf.org/foo/bar?was=foo', 'was=foo')]
136 for uri, expected in DATA:
137 self.assertEqual(simplify_uri(uri), expected)
139 for uri, expected in DATA:
141 self.assertEqual(simplify_uri(n), expected)
143 for uri, expected in DATA:
144 n = RDF.Node(RDF.Uri(uri))
145 self.assertEqual(simplify_uri(n), expected)
147 # decoding literals is questionable
148 n = toTypedNode('http://foo/bar')
149 self.assertRaises(ValueError, simplify_uri, n)
151 def test_owl_import(self):
152 path, name = os.path.split(__file__)
153 #loc = 'file://'+os.path.abspath(path)+'/'
154 loc = os.path.abspath(path)+'/'
157 @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
158 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
159 @prefix owl: <http://www.w3.org/2002/07/owl#> .
161 _:a owl:imports "{loc}extra.turtle" .
163 load_string_into_model(model, 'turtle', fragment, loc)
164 tc = RDF.Node(RDF.Uri('http://jumpgate.caltech.edu/wiki/TestCase'))
165 query = RDF.Statement(tc, rdfsNS['label'], None)
166 result = list(model.find_statements(query))
167 self.failUnlessEqual(len(result), 1)
168 self.failUnlessEqual(str(result[0].object), 'TestCase')
170 def test_sanitize_literal_text(self):
171 self.failUnlessRaises(ValueError, sanitize_literal, "hi")
173 hello_none = RDF.Node(hello_text)
174 self.failUnlessEqual(str(sanitize_literal(hello_none)),
176 hello_str = RDF.Node(literal=hello_text,
177 datatype=xsdNS['string'].uri)
178 hello_clean = sanitize_literal(hello_str)
179 self.failUnlessEqual(hello_clean.literal_value['string'],
182 def test_sanitize_literal_empty_string(self):
184 value_node = RDF.Node(value)
185 self.assertEqual(str(sanitize_literal(value_node)), value)
187 def test_sanitize_literal_html(self):
188 hello = "hello <a onload='javascript:alert(\"foo\");' href='http://google.com'>google.com</a>, whats up?"
189 hello_clean = 'hello <a href="http://google.com">google.com</a>, whats up?'
190 hello_node = RDF.Node(literal=hello,
191 datatype=xsdNS['string'].uri)
192 hello_sanitized = sanitize_literal(hello_node)
193 self.failUnlessEqual(hello_sanitized.literal_value['string'],
196 hostile = "hi <b>there</b><script type='text/javascript>alert('boo');</script><a href='javascript:alert('poke')>evil</a> scammer"
197 hostile_node = RDF.Node(hostile)
198 hostile_sanitized = sanitize_literal(hostile_node)
199 # so it drops the stuff after the javascript link.
200 # I suppose it could be worse
201 hostile_result = """hi <b>there</b>"""
202 self.failUnlessEqual(str(hostile_sanitized), hostile_result)
204 def test_guess_parser_from_file(self):
206 ('/a/b/c.rdf', 'rdfxml'),
207 ('/a/b/c.xml', 'rdfxml'),
208 ('/a/b/c.html', 'rdfa'),
209 ('/a/b/c.turtle', 'turtle'),
210 ('http://foo.bar/bleem.turtle', 'turtle')]
211 for path, parser in DATA:
212 self.assertEqual(guess_parser_by_extension(path), parser)
213 self.assertEqual(guess_parser(None, path), parser)
216 ('application/rdf+xml', 'http://a.org/b/c', 'rdfxml'),
217 ('application/x-turtle', 'http://a.org/b/c', 'turtle'),
218 ('text/html', 'http://a.org/b/c', 'rdfa'),
219 ('text/html', 'http://a.org/b/c.html', 'rdfa'),
220 ('text/plain', 'http://a.org/b/c.turtle', 'turtle'),
221 ('text/plain', 'http://a.org/b/c', 'guess')
223 for contenttype, url, parser in DATA:
224 self.assertEqual(guess_parser(contenttype, url), parser)
226 class TestRDFSchemas(TestCase):
227 def test_rdf_schema(self):
228 """Does it basically work?
231 self.assertEqual(model.size(), 0)
232 add_default_schemas(model)
233 self.assertTrue(model.size() > 0)
234 remove_schemas(model)
235 self.assertEqual(model.size(), 0)
237 def test_included_schemas(self):
239 add_default_schemas(model)
242 s = RDF.Statement(rdfNS[''], dcNS['title'], None)
243 title = model.get_target(rdfNS[''], dcNS['title'])
244 self.assertTrue(title is not None)
246 s = RDF.Statement(rdfNS['Property'], rdfNS['type'], rdfsNS['Class'])
247 self.assertTrue(model.contains_statement(s))
250 s = RDF.Statement(rdfsNS['Class'], rdfNS['type'], rdfsNS['Class'])
251 self.assertTrue(model.contains_statement(s))
253 s = RDF.Statement(owlNS['inverseOf'], rdfNS['type'],
255 self.assertTrue(model.contains_statement(s))
258 except ImportError, e:
259 print "Unable to test rdfhelp"
262 from unittest2 import TestSuite, defaultTestLoader
264 suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFHelp))
265 suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFSchemas))
269 if __name__ == "__main__":
270 from unittest2 import main
271 main(defaultTest="suite")