#!/usr/bin/python # -*- coding: utf-8 -*- import inspect import os import sys import unittest # prefer local copy to the one which is installed # hack from http://stackoverflow.com/a/6098238/280539 _top_level_path = os.path.realpath( os.path.abspath( os.path.join(os.path.split(inspect.getfile(inspect.currentframe()))[0], "..") ) ) if _top_level_path not in sys.path: sys.path.insert(0, _top_level_path) # end of hack import warnings warnings.simplefilter("always") try: from rdflib.graph import ConjunctiveGraph except ImportError: from rdflib import ConjunctiveGraph from SPARQLWrapper import ( CSV, GET, JSON, JSONLD, N3, POST, RDF, RDFXML, TSV, TURTLE, XML, SPARQLWrapper, ) from SPARQLWrapper.SPARQLExceptions import QueryBadFormed from SPARQLWrapper.Wrapper import ( _CSV, _RDF_JSONLD, _RDF_N3, _RDF_TURTLE, _RDF_XML, _SPARQL_JSON, _SPARQL_XML, _TSV, _XML, ) _SPARQL_SELECT_ASK_POSSIBLE = ( _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML ) # only used in test _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = ( _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD ) # only used in test. Same as Wrapper._RDF_POSSIBLE import logging from urllib.error import HTTPError logging.basicConfig() endpoint = "https://agrovoc.fao.org/sparql" prefixes = """ PREFIX rdf: PREFIX rdfs: PREFIX skos: """ selectQuery = """ SELECT ?label WHERE { skos:prefLabel ?label . } """ selectQueryCSV_TSV = """ SELECT ?label ?created WHERE { skos:prefLabel ?label ; ?created } """ askQuery = """ ASK { a ?type } """ constructQuery = """ CONSTRUCT { _:v skos:prefLabel ?label . _:v rdfs:comment "this is only a mock node to test library" } WHERE { skos:prefLabel ?label . } """ describeQuery = """ DESCRIBE """ queryBadFormed = """ PREFIX prop: PREFIX res: FROM SELECT ?lat ?long WHERE { res:Budapest prop:latitude ?lat; prop:longitude ?long. } """ queryManyPrefixes = """ PREFIX conf: PREFIX meta: PREFIX rdf: PREFIX rdfs: PREFIX xsd: PREFIX owl: PREFIX dc: PREFIX dcterms: PREFIX foaf: PREFIX skos: PREFIX geo: PREFIX dbpedia: PREFIX o: PREFIX p: PREFIX yago: PREFIX units: PREFIX geonames: PREFIX prv: PREFIX prvTypes: PREFIX foo: SELECT ?label WHERE { rdfs:label ?label . } """ queryDuplicatedPrefix = """ PREFIX rdf: PREFIX rdf: SELECT ?s ?p ?o WHERE { ?s ?p ?o . } LIMIT 10 """ queryWithCommaInCurie_1 = """ PREFIX dbpedia: SELECT ?article ?title WHERE { ?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia . ?article ?title } """ queryWithCommaInCurie_2 = """ PREFIX dbpedia: SELECT ?article ?title WHERE { ?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia . ?article ?title } """ queryWithCommaInUri = """ SELECT ?article ?title WHERE { ?article ?relation . ?article ?title } """ class SPARQLWrapperTests(unittest.TestCase): def __generic( self, query, returnFormat, method, onlyConneg=True ): # Allegrograph uses only content negotiation (no URL parameters). sparql = SPARQLWrapper(endpoint) sparql.setQuery(prefixes + query) sparql.setReturnFormat(returnFormat) sparql.setMethod(method) sparql.setOnlyConneg(onlyConneg) try: result = sparql.query() except HTTPError: # An ugly way to get the exception, but the only one that works # both on Python 2.5 and Python 3. e = sys.exc_info()[1] if e.code == 400: sys.stdout.write("400 Bad Request, probably query is not well formed") elif e.code == 406: sys.stdout.write("406 Not Acceptable, maybe query is not well formed") else: sys.stdout.write(str(e)) sys.stdout.write("\n") return False else: return result ################################################################################ ################################################################################ ################ #### SELECT #### ################ @unittest.expectedFailure # returned type has changed def testSelectByGETinXML(self): result = self.__generic(selectQuery, XML, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_XML], ct results = result.convert().toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), str) def testSelectByPOSTinXML(self): result = self.__generic(selectQuery, XML, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_XML], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") def testSelectByGETinCSV(self): result = self.__generic(selectQueryCSV_TSV, CSV, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _CSV], ct results = result.convert() self.assertEqual(type(results), bytes) def testSelectByPOSTinCSV(self): result = self.__generic(selectQueryCSV_TSV, CSV, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _CSV], ct results = result.convert() self.assertEqual(type(results), bytes) def testSelectByGETinTSV(self): result = self.__generic(selectQueryCSV_TSV, TSV, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _TSV], ct results = result.convert() self.assertEqual(type(results), bytes) def testSelectByPOSTinTSV(self): result = self.__generic(selectQueryCSV_TSV, TSV, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _TSV], ct results = result.convert() self.assertEqual(type(results), bytes) def testSelectByGETinJSON(self): result = self.__generic(selectQuery, JSON, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_JSON], ct results = result.convert() self.assertEqual(type(results), dict) def testSelectByPOSTinJSON(self): result = self.__generic(selectQuery, JSON, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_JSON], ct results = result.convert() self.assertEqual(type(results), dict) # asking for an unexpected return format for SELECT queryType @unittest.expectedFailure # returned type has changed def testSelectByGETinN3(self): result = self.__generic(selectQuery, N3, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unexpected return format for SELECT queryType @unittest.expectedFailure # returned type has changed def testSelectByPOSTinN3(self): result = self.__generic(selectQuery, N3, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unexpected return format for SELECT queryType @unittest.expectedFailure # returned type has changed def testSelectByGETinJSONLD(self): result = self.__generic(selectQuery, JSONLD, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unexpected return format for SELECT queryType @unittest.expectedFailure # returned type has changed def testSelectByPOSTinJSONLD(self): result = self.__generic(selectQuery, JSONLD, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unknown return format for SELECT queryType (XML is sent) def testSelectByGETinUnknow(self): result = self.__generic(selectQuery, "foo", GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() results.toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # asking for an unknown return format for SELECT queryType (XML is sent) def testSelectByPOSTinUnknow(self): result = self.__generic(selectQuery, "bar", POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() results.toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") ################################################################################ ################################################################################ ############# #### ASK #### ############# def testAskByGETinXML(self): result = self.__generic(askQuery, XML, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_XML], ct results = result.convert() results.toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") def testAskByPOSTinXML(self): result = self.__generic(askQuery, XML, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_XML], ct results = result.convert() results.toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") @unittest.skip( "CSV (text/csv) is not supported currently for AllegroGraph for ASK query type" ) def testAskByGETinCSV(self): result = self.__generic(askQuery, CSV, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _CSV], ct results = result.convert() self.assertEqual(type(results), dict) @unittest.skip( "CSV (text/csv) is not supported currently for AllegroGraph for ASK query type" ) def testAskByPOSTinCSV(self): result = self.__generic(askQuery, CSV, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _CSV], ct results = result.convert() self.assertEqual(type(results), dict) @unittest.skip( "TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type" ) def testAskByGETinTSV(self): result = self.__generic(askQuery, TSV, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _TSV], ct results = result.convert() self.assertEqual(type(results), dict) @unittest.skip( "TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type" ) def testAskByPOSTinTSV(self): result = self.__generic(askQuery, TSV, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _TSV], ct results = result.convert() self.assertEqual(type(results), dict) def testAskByGETinJSON(self): result = self.__generic(askQuery, JSON, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_JSON], ct results = result.convert() self.assertEqual(type(results), dict) def testAskByPOSTinJSON(self): result = self.__generic(askQuery, JSON, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_JSON], ct results = result.convert() self.assertEqual(type(results), dict) # asking for an unexpected return format for ASK queryType @unittest.expectedFailure # returned type has changed def testAskByGETinN3(self): result = self.__generic(askQuery, N3, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unexpected return format for ASK queryType @unittest.expectedFailure # returned type has changed def testAskByPOSTinN3(self): result = self.__generic(askQuery, N3, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unexpected return format for ASK queryType @unittest.expectedFailure # returned type has changed def testAskByGETinJSONLD(self): result = self.__generic(askQuery, JSONLD, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # self.assertEqual(type(results), dict) # asking for an unexpected return format for ASK queryType def testAskByPOSTinJSONLD(self): result = self.__generic(askQuery, JSONLD, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), dict) # asking for an unknown return format for ASK queryType (XML is sent) def testAskByGETinUnknow(self): result = self.__generic(askQuery, "foo", GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() results.toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") # asking for an unknown return format for ASK queryType (XML is sent) def testAskByPOSTinUnknow(self): result = self.__generic(askQuery, "bar", POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct results = result.convert() results.toxml() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") ################################################################################ ################################################################################ ################### #### CONSTRUCT #### ################### def testConstructByGETinXML(self): result = self.__generic(constructQuery, XML, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testConstructByPOSTinXML(self): result = self.__generic(constructQuery, XML, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testConstructByGETinRDFXML(self): result = self.__generic(constructQuery, RDFXML, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testConstructByPOSTinRDFXML(self): result = self.__generic(constructQuery, RDFXML, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testConstructByGETinN3(self): result = self.__generic(constructQuery, N3, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_N3], ct results = result.convert() self.assertEqual(type(results), bytes) def testConstructByPOSTinN3(self): result = self.__generic(constructQuery, N3, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_N3], ct results = result.convert() self.assertEqual(type(results), bytes) # JSON-LD is not supported currently for AllegroGraph @unittest.skip("JSON-LD is not supported currently for AllegroGraph") def testConstructByGETinJSONLD(self): result = self.__generic(constructQuery, JSONLD, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_JSONLD], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # JSON-LD is not supported currently for AllegroGraph @unittest.skip("JSON-LD is not supported currently for AllegroGraph") def testConstructByPOSTinJSONLD(self): result = self.__generic(constructQuery, JSONLD, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_JSONLD], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # asking for an unexpected return format for CONSTRUCT queryType @unittest.expectedFailure # returned type has changed def testConstructByGETinJSON(self): result = self.__generic(constructQuery, JSON, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unexpected return format for CONSTRUCT queryType @unittest.expectedFailure # returned type has changed def testConstructByPOSTinJSON(self): result = self.__generic(constructQuery, JSON, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unexpected return format for CONSTRUCT queryType. For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml @unittest.expectedFailure # returned type has changed def testConstructByGETinCSV(self): result = self.__generic(constructQuery, CSV, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ( "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" % (ct) ) results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unexpected return format for CONSTRUCT queryType. # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml @unittest.expectedFailure # returned type has changed def testConstructByPOSTinCSV(self): result = self.__generic(constructQuery, CSV, POST, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ( "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" % (ct) ) results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unknown return format for CONSTRUCT queryType (XML is sent) def testConstructByGETinUnknow(self): result = self.__generic(constructQuery, "foo", GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # asking for an unknown return format for CONSTRUCT queryType (XML is sent) def testConstructByPOSTinUnknow(self): result = self.__generic(constructQuery, "bar", POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) ################################################################################ ################################################################################ ################## #### DESCRIBE #### ################## def testDescribeByGETinXML(self): result = self.__generic(describeQuery, XML, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testDescribeByPOSTinXML(self): result = self.__generic(describeQuery, XML, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testDescribeByGETinRDFXML(self): result = self.__generic(describeQuery, RDFXML, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testDescribeByPOSTinRDFXML(self): result = self.__generic(describeQuery, RDFXML, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_XML], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) def testDescribeByGETinN3(self): result = self.__generic(describeQuery, N3, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_N3], ct results = result.convert() self.assertEqual(type(results), bytes) def testDescribeByPOSTinN3(self): result = self.__generic(describeQuery, N3, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_N3], ct results = result.convert() self.assertEqual(type(results), bytes) # JSON-LD is not supported currently for AllegroGraph @unittest.skip("JSON-LD is not supported currently for AllegroGraph") def testDescribeByGETinJSONLD(self): result = self.__generic(describeQuery, JSONLD, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_JSONLD], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # JSON-LD is not supported currently for AllegroGraph @unittest.skip("JSON-LD is not supported currently for AllegroGraph") def testDescribeByPOSTinJSONLD(self): result = self.__generic(describeQuery, JSONLD, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_JSONLD], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # asking for an unexpected return format for DESCRIBE queryType @unittest.expectedFailure # returned type has changed def testDescribeByGETinJSON(self): result = self.__generic(describeQuery, JSON, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unexpected return format for DESCRIBE queryType @unittest.expectedFailure # returned type has changed def testDescribeByPOSTinJSON(self): result = self.__generic(describeQuery, JSON, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unexpected return format for DESCRIBE queryType. # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml @unittest.expectedFailure # returned type has changed def testDescribeByGETinCSV(self): result = self.__generic(describeQuery, CSV, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ( "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" % (ct) ) results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unexpected return format for DESCRIBE queryType. # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml @unittest.expectedFailure # returned type has changed def testDescribeByPOSTinCSV(self): result = self.__generic(describeQuery, CSV, POST, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ( "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" % (ct) ) results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # self.assertEqual(type(results), bytes) # asking for an unknown return format for DESCRIBE queryType (XML is sent) def testDescribeByGETinUnknow(self): result = self.__generic(describeQuery, "foo", GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # asking for an unknown return format for DESCRIBE queryType (XML is sent) def testDescribeByPOSTinUnknow(self): result = self.__generic(describeQuery, "bar", POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) ################################################################################ ################################################################################ def testQueryBadFormed(self): self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET) def testQueryManyPrefixes(self): result = self.__generic(queryManyPrefixes, XML, GET) def testQueryDuplicatedPrefix(self): result = self.__generic(queryDuplicatedPrefix, XML, GET) def testKeepAlive(self): sparql = SPARQLWrapper(endpoint) sparql.setQuery("SELECT * WHERE {?s ?p ?o} LIMIT 10") sparql.setReturnFormat(JSON) sparql.setMethod(GET) sparql.setUseKeepAlive() sparql.query() sparql.query() @unittest.skip('Allegrograph returns Value "\\" not recognized Error. See #94') def testQueryWithComma_1(self): result = self.__generic(queryWithCommaInCurie_1, XML, GET) @unittest.skip('Allegrograph returns Value "\\" not recognized Error. See #94') def testQueryWithComma_2(self): result = self.__generic(queryWithCommaInCurie_2, XML, POST) def testQueryWithComma_3(self): result = self.__generic(queryWithCommaInUri, XML, GET) if __name__ == "__main__": unittest.main()