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)