import os
-import unittest
import types
-
+from unittest2 import TestCase
from datetime import datetime
from htsworkflow.util.rdfhelp import \
+ add_default_schemas, \
blankOrUri, \
+ dcNS, \
dump_model, \
fromTypedNode, \
get_model, \
guess_parser, \
guess_parser_by_extension, \
load_string_into_model, \
+ owlNS, \
+ rdfNS, \
rdfsNS, \
+ remove_schemas, \
toTypedNode, \
- stripNamespace, \
+ strip_namespace, \
simplify_uri, \
sanitize_literal, \
xsdNS
try:
import RDF
- class TestRDFHelp(unittest.TestCase):
+ class TestRDFHelp(TestCase):
def test_from_none(self):
- self.failUnlessEqual(fromTypedNode(None), None)
+ self.assertEqual(fromTypedNode(None), None)
def test_typed_node_boolean(self):
node = toTypedNode(True)
- self.failUnlessEqual(node.literal_value['string'], u'1')
- self.failUnlessEqual(str(node.literal_value['datatype']),
+ self.assertIn(node.literal_value['string'], (u'1', u'true'))
+ self.assertEqual(str(node.literal_value['datatype']),
'http://www.w3.org/2001/XMLSchema#boolean')
def test_bad_boolean(self):
node = RDF.Node(literal='bad', datatype=xsdNS['boolean'].uri)
- self.failUnlessRaises(ValueError, fromTypedNode, node)
+ # older versions of librdf ~< 1.0.16 left the literal
+ # alone. and thus should fail the fromTypedNode call
+ # newer versions coerced the odd value to false.
+ try:
+ self.assertFalse(fromTypedNode(node))
+ except ValueError as e:
+ pass
def test_typed_node_string(self):
node = toTypedNode('hello')
- self.failUnlessEqual(node.literal_value['string'], u'hello')
- self.failUnless(node.literal_value['datatype'] is None)
+ self.assertEqual(node.literal_value['string'], u'hello')
+ self.assertTrue(node.literal_value['datatype'] is None)
def test_typed_real_like(self):
num = 3.14
node = toTypedNode(num)
- self.failUnlessEqual(fromTypedNode(node), num)
+ self.assertEqual(fromTypedNode(node), num)
def test_typed_integer(self):
num = 3
node = toTypedNode(num)
- self.failUnlessEqual(fromTypedNode(node), num)
- self.failUnlessEqual(type(fromTypedNode(node)), type(num))
+ self.assertEqual(fromTypedNode(node), num)
+ self.assertEqual(type(fromTypedNode(node)), type(num))
def test_typed_node_string(self):
s = "Argh matey"
node = toTypedNode(s)
- self.failUnlessEqual(fromTypedNode(node), s)
- self.failUnlessEqual(type(fromTypedNode(node)), types.UnicodeType)
+ self.assertEqual(fromTypedNode(node), s)
+ self.assertEqual(type(fromTypedNode(node)), types.UnicodeType)
def test_blank_or_uri_blank(self):
node = blankOrUri()
- self.failUnlessEqual(node.is_blank(), True)
+ self.assertEqual(node.is_blank(), True)
def test_blank_or_uri_url(self):
s = 'http://google.com'
node = blankOrUri(s)
- self.failUnlessEqual(node.is_resource(), True)
- self.failUnlessEqual(str(node.uri), s)
+ self.assertEqual(node.is_resource(), True)
+ self.assertEqual(str(node.uri), s)
def test_blank_or_uri_node(self):
s = RDF.Node(RDF.Uri('http://google.com'))
node = blankOrUri(s)
- self.failUnlessEqual(node.is_resource(), True)
- self.failUnlessEqual(node, s)
+ self.assertEqual(node.is_resource(), True)
+ self.assertEqual(node, s)
def test_unicode_node_roundtrip(self):
literal = u'\u5927'
roundtrip = fromTypedNode(toTypedNode(literal))
- self.failUnlessEqual(roundtrip, literal)
- self.failUnlessEqual(type(roundtrip), types.UnicodeType)
+ self.assertEqual(roundtrip, literal)
+ self.assertEqual(type(roundtrip), types.UnicodeType)
def test_datetime_no_microsecond(self):
dateTimeType = xsdNS['dateTime'].uri
term = 'foo'
node = nsOrg[term]
- self.failUnlessEqual(stripNamespace(nsOrg, node), term)
- self.failUnlessEqual(stripNamespace(nsCom, node), None)
- self.failUnlessEqual(stripNamespace(nsOrg, node.uri), term)
+ self.assertEqual(strip_namespace(nsOrg, node), term)
+ self.assertEqual(strip_namespace(nsCom, node), None)
+ self.assertEqual(strip_namespace(nsOrg, node.uri), term)
def test_strip_namespace_exceptions(self):
nsOrg = RDF.NS('example.org/example#')
nsCom = RDF.NS('example.com/example#')
node = toTypedNode('bad')
- self.failUnlessRaises(ValueError, stripNamespace, nsOrg, node)
- self.failUnlessRaises(ValueError, stripNamespace, nsOrg, nsOrg)
+ self.assertRaises(ValueError, strip_namespace, nsOrg, node)
+ self.assertRaises(ValueError, strip_namespace, nsOrg, nsOrg)
def test_simplify_uri(self):
DATA = [('http://asdf.org/foo/bar', 'bar'),
tc = RDF.Node(RDF.Uri('http://jumpgate.caltech.edu/wiki/TestCase'))
query = RDF.Statement(tc, rdfsNS['label'], None)
result = list(model.find_statements(query))
- self.failUnlessEqual(len(result), 1)
- self.failUnlessEqual(str(result[0].object), 'TestCase')
+ self.assertEqual(len(result), 1)
+ self.assertEqual(str(result[0].object), 'TestCase')
def test_sanitize_literal_text(self):
- self.failUnlessRaises(ValueError, sanitize_literal, "hi")
+ self.assertRaises(ValueError, sanitize_literal, "hi")
hello_text = "hello"
hello_none = RDF.Node(hello_text)
- self.failUnlessEqual(str(sanitize_literal(hello_none)),
+ self.assertEqual(str(sanitize_literal(hello_none)),
hello_text)
hello_str = RDF.Node(literal=hello_text,
datatype=xsdNS['string'].uri)
hello_clean = sanitize_literal(hello_str)
- self.failUnlessEqual(hello_clean.literal_value['string'],
+ self.assertEqual(hello_clean.literal_value['string'],
hello_text)
def test_sanitize_literal_empty_string(self):
hello_node = RDF.Node(literal=hello,
datatype=xsdNS['string'].uri)
hello_sanitized = sanitize_literal(hello_node)
- self.failUnlessEqual(hello_sanitized.literal_value['string'],
+ self.assertEqual(hello_sanitized.literal_value['string'],
hello_clean)
hostile = "hi <b>there</b><script type='text/javascript>alert('boo');</script><a href='javascript:alert('poke')>evil</a> scammer"
# so it drops the stuff after the javascript link.
# I suppose it could be worse
hostile_result = """hi <b>there</b>"""
- self.failUnlessEqual(str(hostile_sanitized), hostile_result)
+ self.assertEqual(str(hostile_sanitized), hostile_result)
def test_guess_parser_from_file(self):
DATA = [
for contenttype, url, parser in DATA:
self.assertEqual(guess_parser(contenttype, url), parser)
- def suite():
- return unittest.makeSuite(TestRDFHelp, 'test')
+ class TestRDFSchemas(TestCase):
+ def test_rdf_schema(self):
+ """Does it basically work?
+ """
+ model = get_model()
+ self.assertEqual(model.size(), 0)
+ add_default_schemas(model)
+ self.assertTrue(model.size() > 0)
+ remove_schemas(model)
+ self.assertEqual(model.size(), 0)
+
+ def test_included_schemas(self):
+ model = get_model()
+ add_default_schemas(model)
+
+ # rdf test
+ s = RDF.Statement(rdfNS[''], dcNS['title'], None)
+ title = model.get_target(rdfNS[''], dcNS['title'])
+ self.assertTrue(title is not None)
+
+ s = RDF.Statement(rdfNS['Property'], rdfNS['type'], rdfsNS['Class'])
+ self.assertTrue(model.contains_statement(s))
+
+ # rdfs test
+ s = RDF.Statement(rdfsNS['Class'], rdfNS['type'], rdfsNS['Class'])
+ self.assertTrue(model.contains_statement(s))
+
+ s = RDF.Statement(owlNS['inverseOf'], rdfNS['type'],
+ rdfNS['Property'])
+ self.assertTrue(model.contains_statement(s))
+
+
except ImportError, e:
print "Unable to test rdfhelp"
- def suite():
- return None
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFHelp))
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFSchemas))
+ return suite
+
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+ from unittest2 import main
+ main(defaultTest="suite")