class test_SMWCreateTemplateFromRDF(unittest.TestCase):
"""
Test.
Test creating pages in the wiki (e.g. using a test wiki)
The connector actually creates pages here
"""
# path to configuration file
configPath = "./test.ini"
# path to example RDF file
rdfpath = "testdata/Test.rdf"
def setUp(self):
"""Setup."""
# Read the configuration file
config = configparser.ConfigParser()
config.read(self.configPath)
self.parser = RDFParser()
self.model = self.parser.parse(self.rdfpath)
self.connector = MediaWikiApiConnector(config)
self.factory = Factory(self.connector, "/src/smw/templates")
def tearDown(self):
"""Teardown."""
self.connector.deletePage("Template:Entry")
self.connector.deletePage("Template:Event")
self.connector.deletePage("Template:Location")
self.connector.deletePage("Template:Description")
self.connector.deletePage("Form:Description")
self.connector.deletePage("Property:hasPriority")
def testProperty(self):
"""Test that a property page can be created."""
# The "Event" class has a property called "Priority"
prop = self.model.classes['Entry'].properties['hasPriority']
dao = self.factory.getDatatypePropertyDAO()
dao.create(prop)
resp = self.connector.loadPage("Property:" + prop.name)
self.assertTrue(resp)
def testSimpleClass(self):
"""Test that a template can be created."""
simpleClass = self.model.classes['Description']
dao = self.factory.getSemanticClassDAO()
dao.create(simpleClass)
# the template should be in the wiki
resp = self.connector.loadPage("Template:" + simpleClass.name)
self.connector.deletePage("Template:" + simpleClass.name)
self.assertTrue(resp)
class test_inheritance(unittest.TestCase):
"""Test."""
parser = None
rdfpath = "testdata/Test3.rdf"
def setUp(self):
"""Setup."""
self.parser = RDFParser()
def test01(self):
"""Test that subclass inherits all properties from superclass."""
model = self.parser.parse(self.rdfpath)
superclass = model.classes["Superclass"]
subclass = model.classes["Subclass"]
self.assertTrue(len(subclass.getPropertyNames()) > 0)
self.assertEqual(superclass.getPropertyNames(),
subclass.getPropertyNames())
class test_MakeMarkdownFromRDF(unittest.TestCase):
"""
Test creating wiki markdown.
The connector is a dummy which does not actually create pages
"""
# path to example RDF file
rdfpath = "testdata/Test.rdf"
# class variables
parser = None
model = None
factory = None
def setUp(self):
"""Setup."""
self.parser = RDFParser()
self.model = self.parser.parse(self.rdfpath)
# stores markdown in factory.value, does not create mediawiki pages
self.factory = DummyDAOFactory()
def testModel(self):
"""Test that sidebar is generated for all classes in the model."""
dao = self.factory.getModelDAO()
dao.create(self.model)
sidebar = dao.getValues()['MediaWiki']
# all classes should be listed in the sidebar
self.assertTrue('Calendar' in sidebar)
self.assertTrue('Description' in sidebar)
self.assertTrue('Entry' in sidebar)
self.assertTrue('Event' in sidebar)
self.assertTrue('Location' in sidebar)
def testProperty(self):
"""Test that property markdown is correct."""
# The "Event" class has a property called "Priority"
prop = self.model.classes['Entry'].properties['hasPriority']
dao = self.factory.getDatatypePropertyDAO()
dao.create(prop)
result = dao.getValues()['property']
self.assertTrue("This is a property of type [[Has type::Text]].\n" in result)
def testSimpleClass(self):
"""Test that template markdown is correct."""
simpleClass = self.model.classes['Description']
classDAO = self.factory.getSemanticClassDAO()
classDAO.create(simpleClass)
result = classDAO.getValues()['template']
self.assertTrue("Description" in result)
self.assertTrue("==Subject" in result)
self.assertTrue("[[hasSubject::{{{hasSubject|}}}]]" in result)
self.assertTrue("==Details" in result)
self.assertTrue("[[hasDetails::{{{hasDetails|}}}]]" in result)
def testClassWithObjectProperties(self):
"""Test that template markdown is correct."""
sClass = self.model.classes['Calendar']
classDAO = self.factory.getSemanticClassDAO()
classDAO.create(sClass)
result = classDAO.getValues()['template']
self.assertTrue("=Entry" in result)
# tplDir = config.get('defaults', 'tplDir')
tplDir = options.templateDir
if not os.path.isdir(tplDir):
raise ImporterException("Template directory not found")
# A connector which can login to a MediaWiki through the API
connector = MediaWikiApiConnector(config)
# A factory for DAO objects which can persist a SemanticModel
daoFactory = Factory(connector, tplDir)
# A wrapper for the import process
importer = Importer(parser, daoFactory)
# Run the importer
if options.command == "import":
importer.run(options.modelPath, options.language)
elif options.command == "remove":
importer.delete(options.modelPath)
elif options.command == "test":
parser.parse(options.modelPath)
print(str(parser._model))
else:
raise ImporterException("Unknown error")
# return to bash
sys.exit(0)
except ImporterException as e:
print(e)
optionsParser.print_help()
sys.exit(1)
class test_RDFParser(unittest.TestCase):
"""Test."""
parser = None
rdfpath = "testdata/Test.rdf"
def setUp(self):
"""Setup."""
self.parser = RDFParser()
def testInstantiate(self):
"""Test that the parser can be instantiated."""
self.assertTrue(self.parser)
def testLoadFile(self):
"""Test that an ontology file can be read."""
self.assertTrue(self.parser.parse(self.rdfpath))
def testParseClasses(self):
"""Test parsing ontology classes."""
model = self.parser.parse(self.rdfpath)
self.assertEqual(5, model.countClasses())
classNames = model.getClassNames()
self.assertTrue("Calendar" in classNames)
self.assertTrue("Event" in classNames)
self.assertTrue("Entry" in classNames)
self.assertTrue("Location" in classNames)
self.assertTrue("Description" in classNames)
def testParseDataPropertyDomains(self):
"""Test parsing domains of data properties."""
model = self.parser.parse(self.rdfpath)
sclass = model.classes['Event']
propNames = sclass.getPropertyNames()
self.assertTrue("hasStartDate" in propNames)
self.assertTrue("hasEndDate" in propNames)
self.assertTrue("isWholeDay" in propNames)
sclass = model.classes['Description']
propNames = sclass.getPropertyNames()
self.assertTrue("hasSubject" in propNames)
self.assertTrue("hasDetails" in propNames)
sclass = model.classes['Location']
propNames = sclass.getPropertyNames()
self.assertTrue("hasName" in propNames)
self.assertTrue("hasDirections" in propNames)
sclass = model.classes['Entry']
propNames = sclass.getPropertyNames()
self.assertTrue("hasPriority" in propNames)
def testParseDataPropertyRanges(self):
"""Test parsing ranges of data properties."""
model = self.parser.parse(self.rdfpath)
sclass = model.classes['Event']
self.assertEqual("dateTime", sclass.properties["hasEndDate"].range)
self.assertEqual("dateTime", sclass.properties["hasStartDate"].range)
self.assertEqual("boolean", sclass.properties["isWholeDay"].range)
def testParseDataPropertyLabels(self):
"""Test parsing labels (localised property names) of data properties."""
model = self.parser.parse(self.rdfpath)
sclass = model.classes['Event']
self.assertEqual("Enddatum",
sclass.properties["hasEndDate"].getLabel('de'))
self.assertEqual("Start date",
sclass.properties["hasStartDate"].getLabel('en'))
def testParseDataPropertyComments(self):
"""Test parsing labels (localised property names) of data properties."""
model = self.parser.parse(self.rdfpath)
sclass = model.classes['Description']
propNames = sclass.getPropertyNames()
self.assertTrue("hasDetails" in propNames)
self.assertTrue("Das ist der Absatz" in
sclass.properties["hasDetails"].getComment('de'))
self.assertTrue("This is the section",
sclass.properties["hasDetails"].getComment('en'))
def testParseDataPropertyAllowedValues(self):
"""Test parsing allowed properties of data properties."""
model = self.parser.parse(self.rdfpath)
sclass = model.classes['Entry']
sprop = sclass.properties['hasPriority']
self.assertTrue(
sorted({'low', 'medium', 'high'}) == sorted(sprop.allowedValues))
def testParseObjectProperties(self):
"""Test parsing object properties."""
model = self.parser.parse(self.rdfpath)
# Entry -> Description
sclass = model.classes['Entry']
propNames = sclass.getPropertyNames()
self.assertTrue("hasDescription" in propNames)
# Calendar -> Entry
sclass = model.classes['Calendar']
propNames = sclass.getPropertyNames()
self.assertTrue("hasEntry" in propNames)
# Entry -> Event
sclass = model.classes['Entry']
propNames = sclass.getPropertyNames()
self.assertTrue("hasEvent" in propNames)
def testParseObjectPropertyRanges(self):
"""Test parsing ranges of object properties."""
model = self.parser.parse(self.rdfpath)
# Entry -> Description
sclass = model.classes['Entry']
self.assertEqual("Description",
sclass.properties["hasDescription"].range)
# Calendar -> Entry
sclass = model.classes['Calendar']
self.assertEqual("Entry", sclass.properties["hasEntry"].range)
# Entry -> Event
sclass = model.classes['Entry']
self.assertEqual("Event", sclass.properties["hasEvent"].range)
def testParseObjectPropertyCardinality(self):
"""Test that global cardinality constraints are parsed correctly and that default is used."""
model = self.parser.parse(self.rdfpath)
# Entry/hasDescription is functional
sclass = model.classes['Entry']
self.assertEqual("FunctionalProperty",
sclass.properties["hasDescription"].cardinality)
# Calendar/hasEntry is not functional
sclass = model.classes['Calendar']
self.assertFalse(sclass.properties["hasEntry"].cardinality)