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 setUp(self):
"""Setup."""
# Read the configuration file
config = configparser.ConfigParser()
config.read(test_SMWImporter.configPath)
# A parser which can parse RDF
self.parser = RDFParser()
# A connector which can login to a MediaWiki through the API
self.connector = MediaWikiApiConnector(config)
# A factory for DAO objects which can persist a SemanticModel
self.daoFactory = Factory(self.connector, "/src/smw/templates")
# A wrapper for the import process
self.importer = Importer(self.parser, self.daoFactory)
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())
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()
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)
def setUp(self):
"""Setup."""
self.parser = RDFParser()
language = None
optionsParser.add_option(
"-l", "--language", default="en", dest="language", help="Language of the wiki")
templateDir = None
optionsParser.add_option("-t", "--templates", default="/src/smw/templates",
dest="templateDir", help="Path to template directory")
(options, args) = optionsParser.parse_args()
print(options)
# Check file type
if not (".rdf" in options.modelPath or ".owl" in options.modelPath):
raise ImporterException("Unknown file type")
# A parser which can parse RDF
from rdf2mw.RDFParser import RDFParser
parser = RDFParser()
# Check command
if options.command not in ['remove', 'import', 'test']:
raise ImporterException("Unknown command")
# Path to templates directory
# if options.templateDir is not None:
# tplDir = options.templateDir
# else:
# 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
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)