class TestEvo(TestROEVOSupport.TestROEVOSupport): TEST_RO_ID = "ro-manager-evo-test-ro" TEST_SNAPHOT_RO_ID = "ro-manager-test-evo-snaphot-ro" TEST_SNAPHOT_ID = "ro-manager-test-evo-snaphot" TEST_CREATED_RO_ID = "" def setUp(self): super(TestEvo, self).setUp() self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") self.TEST_CREATED_RO_ID = rouri return def tearDown(self): (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/") (status, reason) = self.rosrs.deleteRO(self.TEST_CREATED_RO_ID) super(TestEvo, self).tearDown() return def testSnapshot(self): rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, ro_test_config.ROSRS_ACCESS_TOKEN) (copy_status, snapshot_uri) = self.createSnapshot(self.TEST_CREATED_RO_ID, self.TEST_SNAPHOT_ID, False) assert copy_status == "DONE" (status, reason, data, evo_type) = rosrs.getROEvolution(snapshot_uri) assert evo_type == 3 self.freeze(snapshot_uri) (status, reason, data, evo_type) = rosrs.getROEvolution(snapshot_uri) assert evo_type == 1 (status, reason) = self.rosrs.deleteRO(self.TEST_CREATED_RO_ID) (status, reason) = self.rosrs.deleteRO(snapshot_uri) def testArchive(self): rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, ro_test_config.ROSRS_ACCESS_TOKEN) (copy_status, archiveUri) = self.createArchive(self.TEST_CREATED_RO_ID, self.TEST_SNAPHOT_ID, False) assert copy_status == "DONE" (status, reason, data, evo_type) = rosrs.getROEvolution(archiveUri) assert evo_type == 3 self.freeze(archiveUri) (status, reason, data, evo_type) = rosrs.getROEvolution(archiveUri) assert evo_type == 2 (status, reason) = self.rosrs.deleteRO(self.TEST_CREATED_RO_ID) (status, reason) = self.rosrs.deleteRO(archiveUri)
class TestROSRS_Session(unittest.TestCase): """ This test suite tests the ROSRS_Session client implementation of the ROSRS API """ def setUp(self): super(TestROSRS_Session, self).setUp() self.rosrs = ROSRS_Session(Config.ROSRS_API_URI, accesskey=Config.AUTHORIZATION) # Clean up from previous runs self.rosrs.deleteRO(Config.TEST_RO_PATH, purge=True) self.createdTestRO = None return def tearDown(self): super(TestROSRS_Session, self).tearDown() # Clean up self.rosrs.deleteRO(Config.TEST_RO_PATH) if self.createdTestRO: self.rosrs.deleteRO(self.createdTestRO, purge=True) self.rosrs.close() return def createTestRO(self): (status, reason, rouri, manifest) = self.rosrs.createRO(Config.TEST_RO_NAME, "Test RO for ROSRS_Session", "TestROSRS_Session.py", "2012-09-06") self.assertEqual(status, 201) self.createdTestRO = rouri return (status, reason, rouri, manifest) # Actual tests follow def testHelpers(self): testSplitValues() testParseLinks() return def testListROs(self): ros = self.rosrs.listROs() return def testCreateRO(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) self.assertEqual(reason, "Created") self.assertEqual(str(rouri)[:len(Config.TEST_RO_URI)-1]+"/", Config.TEST_RO_URI) self.assertIn((rouri, RDF.type, RO.ResearchObject), manifest) rolist = self.rosrs.listROs() self.assertIn(str(rouri), [ r["uri"] for r in rolist ]) return def testDeleteRO(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Test that new RO is in collection rolist = self.rosrs.listROs() self.assertIn(str(rouri), [ r["uri"] for r in rolist ]) # Delete RO (status, reason) = self.rosrs.deleteRO(rouri) self.assertEqual(status, 204) self.assertEqual(reason, "No Content") # Test that new RO is not in collection rolist = self.rosrs.listROs() self.assertNotIn(str(rouri), [ r["uri"] for r in rolist ]) # Delete again (status, reason) = self.rosrs.deleteRO(rouri) self.assertEqual(status, 404) self.assertEqual(reason, "Not Found") return def testGetROManifest(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Get manifest (status, reason, headers, manifesturi, manifest) = self.rosrs.getROManifest(rouri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertEqual(headers["content-type"], "application/rdf+xml") # Check manifest RDF graph self.assertIn((rouri, RDF.type, RO.ResearchObject), manifest) self.assertIn((rouri, DCTERMS.creator, None), manifest) self.assertIn((rouri, DCTERMS.created, None), manifest) self.assertIn((rouri, ORE.isDescribedBy, manifesturi), manifest) return def testGetROPage(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Get landing page (status, reason, headers, pageuri, page) = self.rosrs.getROLandingPage(rouri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertEqual(headers["content-type"], "text/html;charset=UTF-8") return def testGetROZip(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Get manifest (status, reason, headers, datauri, data) = self.rosrs.getROZip(rouri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertEqual(headers["content-type"], "application/zip") # @@TODO test content of zip (data)? return def testAggregateResourceInt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Aggregate internal resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/path", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) self.assertEqual(reason, "Created") self.assertEqual(str(resuri), str(rouri)+"test/path") # GET content (status, reason, headers, uri, data) = self.rosrs.getROResource( "test/path", rouri) self.assertEqual(status, 200) self.assertEqual(headers["content-type"], "text/plain") self.assertEqual(data, rescontent) # GET proxy (getproxyuri, manifest) = self.rosrs.getROResourceProxy( "test/path", rouri=rouri) self.assertEqual(getproxyuri, proxyuri) return def testDeleteResourceInt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/path", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # GET content (status, reason, headers, uri, data) = self.rosrs.getROResource( "test/path", rouri) self.assertEqual(status, 200) # Delete resource (status, reason) = self.rosrs.removeResource(rouri, resuri) self.assertEqual(status, 204) self.assertEqual(reason, "No Content") # Check that resource is no longer available (status, reason, headers, uri, data) = self.rosrs.getROResource(resuri) self.assertEqual(status, 404) return def testAggregateResourceExt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Aggregate external resource externaluri = rdflib.URIRef("http://example.com/external/resource.txt") (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt( rouri, externaluri) self.assertEqual(status, 201) self.assertEqual(reason, "Created") self.assertEqual(resuri, externaluri) # GET proxy (note: using rdflib.URIRef value for path) (getproxyuri, manifest) = self.rosrs.getROResourceProxy( externaluri, rouri) self.assertEqual(getproxyuri, proxyuri) return def testDeleteResourceExt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create test resource externaluri = rdflib.URIRef("http://example.com/external/resource.txt") (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt( rouri, externaluri) self.assertEqual(status, 201) self.assertEqual(resuri, externaluri) # GET proxy (note: using rdflib.URIRef for path) (getproxyuri, manifest) = self.rosrs.getROResourceProxy( externaluri, rouri) self.assertEqual(getproxyuri, proxyuri) # Delete resource (status, reason) = self.rosrs.removeResource(rouri, resuri) self.assertEqual(status, 204) self.assertEqual(reason, "No Content") (getproxyuri, manifest) = self.rosrs.getROResourceProxy( externaluri, rouri) self.assertIsNone(getproxyuri) self.assertIsNotNone(manifest) return def testGetROResource(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/path", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # GET content (status, reason, headers, uri, data) = self.rosrs.getROResource( "test/path", rouri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertEqual(headers["content-type"], "text/plain") self.assertEqual(data, rescontent) return def testGetROResourceRDF(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create internal test resource rescontent = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" > <rdf:Description rdf:about="http://example.org/file1.txt"> <dct:title>Title for file1.txt</dct:title> </rdf:Description> </rdf:RDF> """ (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/file1.rdf", ctype="application/rdf+xml", body=rescontent) self.assertEqual(status, 201) # Get resource content (status, reason, headers, uri, graph)= self.rosrs.getROResourceRDF( "test/file1.rdf", rouri=rouri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertEqual(headers["content-type"], "application/rdf+xml") s = rdflib.URIRef("http://example.org/file1.txt") self.assertIn((s, DCTERMS.title, rdflib.Literal("Title for file1.txt")), graph) return def testGetROResourceProxy(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create internal test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/path", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # Get resource proxy (getproxyuri, manifest) = self.rosrs.getROResourceProxy( "test/path", rouri=rouri) self.assertEqual(getproxyuri, proxyuri) return def testCreateROAnnotationInt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create internal test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/file.txt", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # Create internal annotation annbody = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="%s" > <rdf:Description rdf:about="test/file.txt"> <dct:title>Title for test/file.txt</dct:title> <rdfs:seeAlso rdf:resource="http://example.org/test" /> </rdf:Description> </rdf:RDF> """%(str(rouri)) agraph = rdflib.graph.Graph() agraph.parse(data=annbody, format="xml") (status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt( rouri, resuri, agraph) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve annotation URIs auris = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris) buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) ### self.assertIn(bodyuri, buris) # Retrieve annotation (status, reason, bodyuri, anngr) = self.rosrs.getROAnnotation(annuri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for test/file.txt")), anngr) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), anngr) return def testGetROAnnotationGraph(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create internal test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/file.txt", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # Create internal annotation annbody = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="%s" > <rdf:Description rdf:about="test/file.txt"> <dct:title>Title for test/file.txt</dct:title> <rdfs:seeAlso rdf:resource="http://example.org/test" /> </rdf:Description> </rdf:RDF> """%(str(rouri)) agraph = rdflib.graph.Graph() agraph.parse(data=annbody, format="xml") (status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt( rouri, resuri, agraph) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve merged annotations anngr = self.rosrs.getROAnnotationGraph(rouri, resuri) annts = list(anngr.triples((None, None, None))) self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for test/file.txt")), annts) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), annts) return def testCreateROAnnotationExt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create external test resource (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt( rouri, rdflib.URIRef("http://example.org/ext")) self.assertEqual(status, 201) # Create annotation using external body reference bodyuri = rdflib.URIRef("http://example.org/ext/ann.rdf") (status, reason, annuri) = self.rosrs.createROAnnotationExt(rouri, resuri, bodyuri) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve annotation URIs auris = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris) buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) ### self.assertIn(bodyuri, buris) return def testUpdateROAnnotationInt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create internal test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/file.txt", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # Create internal annotation annbody1 = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="%s" > <rdf:Description rdf:about="test/file.txt"> <dct:title>Title 1</dct:title> <rdfs:seeAlso rdf:resource="http://example.org/test1" /> </rdf:Description> </rdf:RDF> """%(str(rouri)) agraph1 = rdflib.graph.Graph() agraph1.parse(data=annbody1, format="xml") (status, reason, annuri, bodyuri1) = self.rosrs.createROAnnotationInt( rouri, resuri, agraph1) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve annotation URIs auris1 = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris1) buris1 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) ### self.assertIn(bodyuri1, buris1) # Retrieve annotation (status, reason, auri1, anngr1a) = self.rosrs.getROAnnotation(annuri) self.assertEqual(status, 200) self.assertEqual(reason, "OK") annts1a = list(anngr1a.triples((None, None, None))) self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts1a) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts1a) # Retrieve merged annotations anngr1b = self.rosrs.getROAnnotationGraph(rouri, resuri) annts1b = list(anngr1b.triples((None, None, None))) self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts1b) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts1b) # Update internal annotation annbody2 = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="%s" > <rdf:Description rdf:about="test/file.txt"> <dct:title>Title 2</dct:title> <rdfs:seeAlso rdf:resource="http://example.org/test2" /> </rdf:Description> </rdf:RDF> """%(str(rouri)) agraph2 = rdflib.graph.Graph() agraph2.parse(data=annbody2, format="xml") (status, reason, bodyuri2) = self.rosrs.updateROAnnotationInt( rouri, annuri, resuri, agraph2) self.assertEqual(status, 200) self.assertEqual(reason, "OK") # Retrieve annotation URIs auris2 = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris2) buris2 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) ### self.assertIn(bodyuri2, buris2) # Retrieve annotation (status, reason, auri2a, anngr2a) = self.rosrs.getROAnnotation(annuri) annts2a = list(anngr2a.triples((None, None, None))) self.assertEqual(status, 200) self.assertEqual(reason, "OK") self.assertNotIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts2a) self.assertNotIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts2a) self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 2")), annts2a) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test2")), annts2a) # Retrieve merged annotations anngr2b = self.rosrs.getROAnnotationGraph(rouri, resuri) annts2b = list(anngr2b.triples((None, None, None))) self.assertNotIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts2b) self.assertNotIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts2b) self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 2")), annts2b) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test2")), annts2b) return def testUpdateROAnnotationExt(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create external test resource (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt( rouri, rdflib.URIRef("http://example.org/ext")) self.assertEqual(status, 201) # Create annotation using external body reference bodyuri1 = rdflib.URIRef("http://example.org/ext/ann1.rdf") (status, reason, annuri) = self.rosrs.createROAnnotationExt(rouri, resuri, bodyuri1) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve annotation URIs auris1 = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris1) buris1 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) self.assertIn(bodyuri1, buris1) # Update annotation using external body reference # @@TODO - this doesn't check that old annotation is removed. # @@TODO - currently, update is not fully implemented (2013-05). bodyuri2 = rdflib.URIRef("http://example.org/ext/ann2.rdf") (status, reason, annuri) = self.rosrs.createROAnnotationExt(rouri, resuri, bodyuri2) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve annotation URIs auris2 = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris2) buris2 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) self.assertIn(bodyuri1, buris2) return def testRemoveROAnnotation(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) # Create internal test resource rescontent = "Resource content\n" (status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, "test/file.txt", ctype="text/plain", body=rescontent) self.assertEqual(status, 201) # Create internal annotation annbody = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="%s" > <rdf:Description rdf:about="test/file.txt"> <dct:title>Title for test/file.txt</dct:title> <rdfs:seeAlso rdf:resource="http://example.org/test" /> </rdf:Description> </rdf:RDF> """%(str(rouri)) agraph = rdflib.graph.Graph() agraph.parse(data=annbody, format="xml") (status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt( rouri, resuri, agraph) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # Retrieve annotation URIs auris = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertIn(annuri, auris) buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) ### self.assertIn(bodyuri, buris) # Remove the annotation (status, reason) = self.rosrs.removeROAnnotation(rouri, annuri) self.assertEqual(status, 204) self.assertEqual(reason, "No Content") # Retrieve annotation URIs auris = list(self.rosrs.getROAnnotationUris(rouri, resuri)) self.assertNotIn(annuri, auris) buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri)) ### self.assertNotIn(bodyuri, buris) return # Evolution tests def testCopyRO(self): return def testCancelCopyRO(self): return def testUpdateROStatus(self): return def testGetROEvolution(self): return # Sentinel/placeholder tests def testUnits(self): assert (True) def testComponents(self): assert (True) def testIntegration(self): assert (True) def testPending(self): assert (False), "Pending tests follow"
class TestEvoCommands(TestROEVOSupport.TestROEVOSupport): TEST_RO_ID = "ro-manger-evo-test-ro" TEST_SNAPHOT_ID = "ro-manager-evo-test-snaphot" TEST_ARCHIVE_ID = "ro-manager-evo-test-archive-id" TEST_UNDEFINED_ID = "ro-manager-evo-test-undefined-id" CREATED_RO = "" def setUp(self): super(TestEvoCommands, self).setUp() self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") self.CREATED_RO = rouri; return def tearDown(self): (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/") (status, reason) = self.rosrs.deleteRO(self.CREATED_RO) super(TestEvoCommands, self).tearDown() return def testSnapshot(self): """ snapshot <live-RO> <snapshot-id> [ --asynchronous ] [ --freeze ] [ -t <access_token> ] [ -t <token> ] """ return def testSnapshotAsynchronous(self): args = [ "ro", "snapshot" , str(self.CREATED_RO), self.TEST_SNAPHOT_ID, "--asynchronous", "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] outLines = "" with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 # simple check if the verbouse mode works well for word in ("ro snapshot --asynchronous "+ro_test_config.ROSRS_URI + self.TEST_RO_ID + " " + self.TEST_SNAPHOT_ID).split(" "): self.assertTrue(self.outstr.getvalue().count(word+ " ") or self.outstr.getvalue().count(" " + word), "snapshot command wasn't parse well") self.assertEqual(self.outstr.getvalue().count("Job Status: "), 1) self.assertEqual(self.outstr.getvalue().count("Job URI: "), 1) self.assertEqual(self.outstr.getvalue().count("Target URI: "), 1) self.assertEqual(self.outstr.getvalue().count("Target Name: "), 1) self.assertEqual(self.outstr.getvalue().count("Response Status: "), 1) self.assertEqual(self.outstr.getvalue().count("Response Reason: "), 1) outLines = self.outstr.getvalue().split("\n") for line in outLines: if "Job URI:" in line: jobLocation = line.split("Job URI:")[1].strip() status = "RUNNING" while status == "RUNNING": (status, id) = parse_job(self.rosrs, jobLocation) assert status == "DONE" self.rosrs.deleteRO(id) return def testSnapshotSynchronous(self): args = [ "ro", "snapshot", self.CREATED_RO, self.TEST_SNAPHOT_ID, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] outLines = "" with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 # simple check if the verbouse mode works well for word in ("ro snaphot "+ro_test_config.ROSRS_URI + self.TEST_RO_ID + " " + self.TEST_SNAPHOT_ID).split(" "): self.assertTrue(self.outstr.getvalue().count(word+ " ") or self.outstr.getvalue().count(" " + word), "snapshot command wasn't parse well") self.assertEqual(self.outstr.getvalue().count("Target URI: "), 1) outLines = self.outstr.getvalue().split("\n") for line in outLines: if "Target URI:" in line: id = line.split("Target URI:")[1].strip() self.rosrs.deleteRO(id) return def testSnapshotWithEscOption(self): args = [ "ro", "snapshot", self.CREATED_RO, self.TEST_SNAPHOT_ID, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] outLines = "" with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 # simple check if the verbouse mode works well self.assertEqual(self.outstr.getvalue().count("--asynchronous"), 0, "shouldn't be asynchronous") outLines = self.outstr.getvalue().split("\n") for line in outLines: if "Target URI:" in line: id = line.split("Target URI:")[1].strip() self.rosrs.deleteRO(id) return def testArchive(self): """ archive <live-RO> <snapshot-id> [ --asynchronous ] [ --freeze ] [ -t <access_token> ] [ -t <token> ] """ return def testArchiveAsynchronous(self): args = [ "ro", "archive" , str(self.CREATED_RO), self.TEST_SNAPHOT_ID, "--asynchronous", "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] outLines = "" with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 # simple check if the verbouse mode works well for word in ("ro archive --asynchronous "+ro_test_config.ROSRS_URI + self.TEST_RO_ID + " " + self.TEST_SNAPHOT_ID).split(" "): self.assertTrue(self.outstr.getvalue().count(word+ " ") or self.outstr.getvalue().count(" " + word), "snapshot command wasn't parse well") self.assertEqual(self.outstr.getvalue().count("Job Status: "), 1) self.assertEqual(self.outstr.getvalue().count("Job URI: "), 1) self.assertEqual(self.outstr.getvalue().count("Target URI: "), 1) self.assertEqual(self.outstr.getvalue().count("Target Name: "), 1) self.assertEqual(self.outstr.getvalue().count("Response Status: "), 1) self.assertEqual(self.outstr.getvalue().count("Response Reason: "), 1) outLines = self.outstr.getvalue().split("\n") for line in outLines: if "Job URI:" in line: jobLocation = line.split("Job URI:")[1].strip() status = "RUNNING" while status == "RUNNING": (status, id) = parse_job(self.rosrs, jobLocation) assert status == "DONE" self.rosrs.deleteRO(id) return def testArchiveSynchronous(self): args = [ "ro", "archive", ro_test_config.ROSRS_URI + self.TEST_RO_ID, ro_test_config.ROSRS_URI + self.TEST_SNAPHOT_ID, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] outLines = "" with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 # simple check if the verbouse mode works well self.assertEqual(self.outstr.getvalue().count("--asynchronous"), 0, "shouldn't be asynchronous") outLines = self.outstr.getvalue().split("\n") for line in outLines: if "Target URI:" in line: id = line.split("Target URI:")[1].strip() self.rosrs.deleteRO(id) return def testFreeze(self): """ freeze <RO-id> """ #preapre snaphot (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/") (status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") (createdSnapshotStatus, createdSnapshotId) = self.createSnapshot(createdRoUri, self.TEST_SNAPHOT_ID, False) args = [ "ro", "freeze",str(createdSnapshotId), "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 self.assertEqual(self.outstr.getvalue().count("freeze operation finished successfully"), 1) (status, reason) = self.rosrs.deleteRO(createdRoUri) (status, reason) = self.rosrs.deleteRO(createdSnapshotId) return def FreezeNonExistetSnaphot(self): """ freeze <RO-id> """ #preapre snaphot (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/") (status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") self.createSnapshot(self.TEST_RO_ID+"/", self.TEST_SNAPHOT_ID, True) args = [ "ro", "freeze", self.TEST_SNAPHOT_RO_ID + "non exited", "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-r", ro_test_config.ROSRS_URI, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == -1 self.assertEqual(self.outstr.getvalue().count("Given URI isn't correct"), 0) (status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/") (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") return def testRemoteStatusSnapshotRO(self): self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") (status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID + "/") (createdSnapshotStatus, createdSnapshotUri) = self.createSnapshot(createdRoUri, self.TEST_SNAPHOT_ID, True) args = [ "ro", "status", str(createdSnapshotUri), "-r", ro_test_config.ROSRS_URI, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 outtxt = self.outstr.getvalue() self.assertEqual(outtxt.count("SNAPSHOT"), 1) (status, reason) = self.rosrs.deleteRO(createdSnapshotUri) (status, reason) = self.rosrs.deleteRO(createdRoUri) return def testRemoteStatusArchiveRO(self): self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") (status, reason) = self.rosrs.deleteRO(self.TEST_ARCHIVE_ID + "/") (createdArchiveStatus, createdArchiveUri) = self.createArchive(createdRoUri, self.TEST_ARCHIVE_ID, True) args = [ "ro", "status", str(createdArchiveUri), "-r", ro_test_config.ROSRS_URI, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 outtxt = self.outstr.getvalue() self.assertEqual(outtxt.count("ARCHIVE"), 1) (status, reason) = self.rosrs.deleteRO(createdArchiveUri) (status, reason) = self.rosrs.deleteRO(createdRoUri) return def testRemoteStatusUndefinedRO(self): self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") (status, reason) = self.rosrs.deleteRO(self.TEST_ARCHIVE_ID + "/") (createdArchiveStatus, createdArchiveUri) = self.createArchive(createdRoUri, self.TEST_ARCHIVE_ID, False) args = [ "ro", "status", str(createdArchiveUri), "-r", ro_test_config.ROSRS_URI, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 outtxt = self.outstr.getvalue() self.assertEqual(outtxt.count("UNDEFINED"), 1) (status, reason) = self.rosrs.deleteRO(createdArchiveUri) (status, reason) = self.rosrs.deleteRO(createdRoUri) return def testRemoteStatusLiveRO(self): self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) (status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/") (status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID, "Test RO for ROEVO", "Test Creator", "2012-09-06") args = [ "ro", "status", str(rouri), "-r", ro_test_config.ROSRS_URI, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) assert status == 0 outtxt = self.outstr.getvalue() self.assertEqual(outtxt.count("LIVE"), 1) (status, reason) = self.rosrs.deleteRO(rouri) return def testRemoteStatusWithWrongUriGiven(self): self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN) self.rosrs.deleteRO(self.TEST_RO_ID + "/") self.rosrs.deleteRO("some-strange-uri/") args = [ "ro", "status", ro_test_config.ROSRS_URI + "some-strange-uri/", "-r", ro_test_config.ROSRS_URI, "-t", ro_test_config.ROSRS_ACCESS_TOKEN, "-v" ] with SwitchStdout(self.outstr): status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args) outtxt = self.outstr.getvalue() assert status == -1 self.assertEqual(outtxt.count("Wrong URI was given"), 1) self.rosrs.deleteRO(self.TEST_RO_ID + "/") return
class TestROSRSMetadata(TestROSupport.TestROSupport): """ Test ro metadata access via ROSRS API """ def setUp(self): super(TestROSRSMetadata, self).setUp() self.rosrs = ROSRS_Session(Config.ROSRS_API_URI, accesskey=Config.AUTHORIZATION) # Clean up from previous runs self.rosrs.deleteRO(Config.TEST_RO_PATH) return def tearDown(self): super(TestROSRSMetadata, self).tearDown() # Clean up self.rosrs.deleteRO(Config.TEST_RO_PATH) self.rosrs.close() return def createTestRO(self): (status, reason, rouri, manifest) = self.rosrs.createRO(Config.TEST_RO_NAME, "Test RO for ROSRSMetadata", "TestROSRSMetadata.py", "2012-09-11") self.assertEqual(status, 201) # Include manifest as annotation of RO (s1, r1, h1, manifesturi, manifest) = self.rosrs.getROManifest(rouri) self.assertEqual(s1, 200) (s2, r2, annuri) = self.rosrs.createROAnnotationExt( rouri, rouri, manifesturi) self.assertEqual(s2, 201) # Aggregate internal resource rescontent = "Resource content\n" (s3, r3, proxyuri, resuri) = self.rosrs.aggregateResourceInt( rouri, Config.TEST_RESOURCE, ctype="text/plain", body=rescontent) self.assertEqual(s3, 201) self.assertEqual(r3, "Created") self.assertEqual(str(resuri), str(rouri)+Config.TEST_RESOURCE) # Aggregate external resource externaluri = rdflib.URIRef(Config.TEST_EXTERNAL) (s4, r4, proxyuri, resuri) = self.rosrs.aggregateResourceExt( rouri, externaluri) self.assertEqual(s4, 201) self.assertEqual(r4, "Created") self.assertEqual(str(resuri), Config.TEST_EXTERNAL) return (status, reason, rouri, manifest) def createTestAnnotation(self, rouri, resuri, resref): annbody = """<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dct="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="%(rouri)s" > <rdf:Description rdf:about="%(resuri)s"> <dct:title>Title for %(resref)s</dct:title> <rdfs:seeAlso rdf:resource="http://example.org/test" /> </rdf:Description> </rdf:RDF> """%{"rouri": str(rouri), "resuri": str(resuri), "resref": resref} agraph = rdflib.graph.Graph() agraph.parse(data=annbody, format="xml") (status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt( rouri, resuri, agraph) self.assertEqual(status, 201) return (status, reason, annuri, bodyuri) # Actual tests follow def testNull(self): assert True, 'Null test failed' def testCreateRoMetadata(self): """ Test creation of ro_metadata object, and basic access to manifest content """ (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) self.assertEqual(reason, "Created") self.assertEqual(str(rouri), Config.TEST_RO_URI) self.assertIn((rouri, RDF.type, RO.ResearchObject), manifest) romd = ro_metadata.ro_metadata(ro_config, rouri) resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE) exturi = romd.getComponentUriAbs(Config.TEST_EXTERNAL) resref = Config.TEST_RESOURCE (status, reason, annuri, bodyuri) = self.createTestAnnotation(rouri, resuri, resref) self.assertEqual(status, 201) self.assertEqual(reason, "Created") # self.assertEquals(romd.rouri, rouri) self.assertTrue(romd.roManifestContains((rouri, RDF.type, RO.ResearchObject))) self.assertTrue(romd.roManifestContains((rouri, ORE.aggregates, resuri))) self.assertTrue(romd.roManifestContains((rouri, ORE.aggregates, exturi))) return def testReadRoAnnotationBody(self): """ Test function to create & read a simple annotation body on an RO """ (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) romd = ro_metadata.ro_metadata(ro_config, rouri) resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE) resref = Config.TEST_RESOURCE (status, reason, bodyuri, agraph) = self.createTestAnnotation(rouri, resuri, resref) self.assertEqual(status, 201) # Retrieve annotations anns = list(romd.getFileAnnotations(Config.TEST_RESOURCE)) self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for "+Config.TEST_RESOURCE)), anns) self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), anns) return def testGetInitialRoAnnotations(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) romd = ro_metadata.ro_metadata(ro_config, rouri) # Retrieve the anotations annotations = romd.getRoAnnotations() rouri = romd.getRoUri() expected_annotations = ( [ (rouri, RDF.type, RO.ResearchObject) , (rouri, RDF.type, ROEVO.LiveRO) , (rouri, ORE.isDescribedBy, romd.getComponentUriAbs(ro_test_config.ROMANIFESTPATH)) #, (rouri, DCTERMS.description, rdflib.Literal('Test init RO annotation')) #, (rouri, DCTERMS.title, rdflib.Literal('Test init RO annotation')) #, (rouri, DCTERMS.created, rdflib.Literal('unknown')) #, (rouri, DCTERMS.creator, rdflib.Literal('Test User')) #, (rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate')) ]) count = 0 for next in list(annotations): if ( not isinstance(next[2], rdflib.BNode) and not next[1] in [ORE.aggregates, DCTERMS.created, DCTERMS.creator] ): log.debug("- next %s"%(str(next[0])) ) log.debug(" - (%s, %s)"%(str(next[1]),str(next[2])) ) if next in expected_annotations: count += 1 else: self.assertTrue(False, "Not expected (%d) %s"%(count, repr(next))) self.assertEqual(count,3) return def testQueryAnnotations(self): (status, reason, rouri, manifest) = self.createTestRO() self.assertEqual(status, 201) romd = ro_metadata.ro_metadata(ro_config, rouri) resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE) resref = Config.TEST_RESOURCE (status, reason, bodyuri, agraph) = self.createTestAnnotation(rouri, resuri, resref) self.assertEqual(status, 201) # Query the file anotations queryprefixes = """ PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX ro: <http://purl.org/wf4ever/ro#> PREFIX ore: <http://www.openarchives.org/ore/terms/> PREFIX ao: <http://purl.org/ao/> PREFIX dcterms: <http://purl.org/dc/terms/> PREFIX roterms: <http://ro.example.org/ro/terms/> """ query = (queryprefixes + """ ASK { ?ro rdf:type ro:ResearchObject ; dcterms:creator ?user . } """) resp = romd.queryAnnotations(query) self.assertTrue(resp, "Expected 'True' result for query: %s"%(query)) query = (queryprefixes + """ ASK { <%(resuri)s> dcterms:title ?title . } """%{"resuri": str(resuri)}) resp = romd.queryAnnotations(query) self.assertTrue(resp, "Expected 'True' result for query: %s"%(query)) query = (queryprefixes + """ ASK { ?ro rdf:type ro:ResearchObject ; dcterms:creator "Not user" . } """) resp = romd.queryAnnotations(query) self.assertFalse(resp, "Expected 'False' result for query: %s"%(query)) query = (queryprefixes + """ SELECT * WHERE { ?ro rdf:type ro:ResearchObject ; ore:aggregates ?file . ?file dcterms:title ?title . } """) rouri = romd.getRoUri() resp = romd.queryAnnotations(query) self.assertEqual(resp[0]['ro'], rouri) self.assertEqual(resp[0]['file'], resuri) self.assertEqual(resp[0]['title'], rdflib.Literal("Title for %s"%(Config.TEST_RESOURCE))) return # Sentinel/placeholder tests def testUnits(self): assert (True) def testComponents(self): assert (True) def testIntegration(self): assert (True) def testPending(self): assert (False), "Pending tests follow"