#!/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://lov.linkeddata.es/dataset/lov/sparql/" # Fuseki - version 1.1.1 (Build date: 2014-10-02T16:36:17+0100) prefixes = """ PREFIX vann: PREFIX voaf: PREFIX rdf: PREFIX rdfs: PREFIX skos: """ selectQuery = """ SELECT DISTINCT ?vocabPrefix ?vocabURI { GRAPH { ?vocabURI a voaf:Vocabulary. ?vocabURI vann:preferredNamespacePrefix ?vocabPrefix. }} ORDER BY ?vocabPrefix """ selectQueryCSV_TSV = """ SELECT DISTINCT ?vocabPrefix ?vocabURI { GRAPH { ?vocabURI a voaf:Vocabulary. ?vocabURI vann:preferredNamespacePrefix ?vocabPrefix. }} ORDER BY ?vocabPrefix """ askQuery = """ ASK { a } """ constructQuery = """ CONSTRUCT { _:v skos:prefLabel ?label . _:v rdfs:comment "this is only a mock node to test library" } WHERE { rdfs:label ?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=False ): # Fuseki uses 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 #### ################ 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() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") def testSelectByGETinXML_Conneg(self): result = self.__generic(selectQuery, XML, GET, onlyConneg=True) 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") @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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") @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinXML_Conneg(self): result = self.__generic(selectQuery, XML, POST, onlyConneg=True) 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 testSelectByGETinCSV_Conneg(self): result = self.__generic(selectQueryCSV_TSV, CSV, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _CSV], ct results = result.convert() self.assertEqual(type(results), bytes) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinCSV_Conneg(self): result = self.__generic(selectQueryCSV_TSV, CSV, POST, onlyConneg=True) 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 testSelectByGETinTSV_Conneg(self): result = self.__generic(selectQueryCSV_TSV, TSV, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _TSV], ct results = result.convert() self.assertEqual(type(results), bytes) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinTSV_Conneg(self): result = self.__generic(selectQueryCSV_TSV, TSV, POST, onlyConneg=True) 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 testSelectByGETinJSON_Conneg(self): result = self.__generic(selectQuery, JSON, GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinJSON_Conneg(self): result = self.__generic(selectQuery, JSON, POST, onlyConneg=True) 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 (n3 is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testSelectByGETinN3_Unexpected(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(type(results), dict) # Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testSelectByGETinN3_Unexpected_Conneg(self): result = self.__generic(selectQuery, N3, GET, onlyConneg=True) 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 unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinN3_Unexpected(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(type(results), dict) # Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinN3_Unexpected_Conneg(self): result = self.__generic(selectQuery, N3, POST, onlyConneg=True) 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 unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testSelectByGETinJSONLD_Unexpected(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(type(results), dict) # Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testSelectByGETinJSONLD_Unexpected_Conneg(self): result = self.__generic(selectQuery, JSONLD, GET, onlyConneg=True) 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 unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinJSONLD_Unexpected(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(type(results), dict) # Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). # Set by default None (and sending */*). # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinJSONLD_Unexpected_Conneg(self): result = self.__generic(selectQuery, JSONLD, POST, onlyConneg=True) 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 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() 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 testSelectByGETinUnknow_Conneg(self): result = self.__generic(selectQuery, "foo", GET, onlyConneg=True) 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") # Asking for an unknown return format for SELECT queryType (XML is sent) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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() 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testSelectByPOSTinUnknow_Conneg(self): result = self.__generic(selectQuery, "bar", POST, onlyConneg=True) 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") ################################################################################ ################################################################################ ############# #### 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() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") def testAskByGETinXML_Conneg(self): result = self.__generic(askQuery, XML, GET, onlyConneg=True) 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") @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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() self.assertEqual(results.__class__.__module__, "xml.dom.minidom") self.assertEqual(results.__class__.__name__, "Document") @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinXML_Conneg(self): result = self.__generic(askQuery, XML, POST, onlyConneg=True) 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 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), bytes) def testAskByGETinCSV_Conneg(self): result = self.__generic(askQuery, CSV, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _CSV], ct results = result.convert() self.assertEqual(type(results), bytes) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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), bytes) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinCSV_Conneg(self): result = self.__generic(askQuery, CSV, POST, onlyConneg=True) 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 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), bytes) def testAskByGETinTSV_Conneg(self): result = self.__generic(askQuery, TSV, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _TSV], ct results = result.convert() self.assertEqual(type(results), bytes) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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), bytes) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinTSV_Conneg(self): result = self.__generic(askQuery, TSV, POST, onlyConneg=True) 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 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 testAskByGETinJSON_Conneg(self): result = self.__generic(askQuery, JSON, GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinJSON_Conneg(self): result = self.__generic(askQuery, JSON, POST, onlyConneg=True) 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 (n3 is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testAskByGETinN3_Unexpected(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(type(results), dict) # Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testAskByGETinN3_Unexpected_Conneg(self): result = self.__generic(askQuery, N3, GET, onlyConneg=True) 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 unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinN3_Unexpected(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(type(results), dict) # Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinN3_Unexpected_Conneg(self): result = self.__generic(askQuery, N3, POST, onlyConneg=True) 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 unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testAskByGETinJSONLD_Unexpected(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(type(results), dict) # Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json def testAskByGETinJSONLD_Unexpected_Conneg(self): result = self.__generic(askQuery, JSONLD, GET, onlyConneg=True) 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 unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinJSONLD_Unexpected(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 unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). # Set by default None (and sending */*). # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinJSONLD_Unexpected_Conneg(self): result = self.__generic(askQuery, JSONLD, POST, onlyConneg=True) 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() 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 testAskByGETinUnknow_Conneg(self): result = self.__generic(askQuery, "foo", GET, onlyConneg=True) 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") # Asking for an unknown return format for ASK queryType (XML is sent) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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() 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testAskByPOSTinUnknow_Conneg(self): result = self.__generic(askQuery, "bar", POST, onlyConneg=True) 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") ################################################################################ ################################################################################ ################### #### 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 testConstructByGETinXML_Conneg(self): result = self.__generic(constructQuery, XML, GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinXML_Conneg(self): result = self.__generic(constructQuery, XML, POST, onlyConneg=True) 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) # rdf+xml is not a valid alias 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) # rdf+xml is not a valid alias def testConstructByGETinRDFXML_Conneg(self): result = self.__generic(constructQuery, RDFXML, GET, onlyConneg=True) 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) # rdf+xml is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # rdf+xml is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinRDFXML_Conneg(self): result = self.__generic(constructQuery, RDFXML, POST, onlyConneg=True) 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) # turtle is not a valid alias def testConstructByGETinTURTLE(self): result = self.__generic(constructQuery, TURTLE, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # turtle is not a valid alias def testConstructByGETinTURTLE_Conneg(self): result = self.__generic(constructQuery, TURTLE, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # turtle is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinTURTLE(self): result = self.__generic(constructQuery, TURTLE, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # turtle is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinTURTLE_Conneg(self): result = self.__generic(constructQuery, TURTLE, POST, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # n3 is not a valid alias 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) # n3 is not a valid alias def testConstructByGETinN3_Conneg(self): result = self.__generic(constructQuery, N3, GET, onlyConneg=True) 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) # n3 is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # n3 is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinN3_Conneg(self): result = self.__generic(constructQuery, N3, POST, onlyConneg=True) 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 a valid alias. Use content negotiation instead 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 a valid alias. Use content negotiation instead def testConstructByGETinJSONLD_Conneg(self): result = self.__generic(constructQuery, JSONLD, GET, onlyConneg=True) 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 a valid alias. Use content negotiation instead @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # json-ld is not a valid alias. Use content negotiation instead @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinJSONLD_Conneg(self): result = self.__generic(constructQuery, JSONLD, POST, onlyConneg=True) 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. # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle def testConstructByGETinCSV_Unexpected(self): result = self.__generic(constructQuery, CSV, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() 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 text/turtle def testConstructByGETinCSV_Unexpected_Conneg(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] results = result.convert() 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 text/turtle @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinCSV_Unexpected(self): result = self.__generic(constructQuery, CSV, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() 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 text/turtle @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinCSV_Unexpected_Conneg(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] results = result.convert() 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 text/turtle # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) def testConstructByGETinJSON_Unexpected(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] results = result.convert() 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 text/turtle def testConstructByGETinJSON_Unexpected_Conneg(self): result = self.__generic(constructQuery, JSON, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() 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 text/turtle # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinJSON_Unexpected(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) # Asking for an unexpected return format for CONSTRUCT queryType. # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinJSON_Unexpected_Conneg(self): result = self.__generic(constructQuery, JSON, POST, onlyConneg=True) 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), 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 testConstructByGETinUnknow_Conneg(self): result = self.__generic(constructQuery, "foo", GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # Asking for an unknown return format for CONSTRUCT queryType (XML is sent) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testConstructByPOSTinUnknow_Conneg(self): result = self.__generic(constructQuery, "bar", POST, onlyConneg=True) 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 testDescribeByGETinXML_Conneg(self): result = self.__generic(describeQuery, XML, GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinXML_Conneg(self): result = self.__generic(describeQuery, XML, POST, onlyConneg=True) 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) # rdf+xml is not a valid alias 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) # rdf+xml is not a valid alias def testDescribeByGETinRDFXML_Conneg(self): result = self.__generic(describeQuery, RDFXML, GET, onlyConneg=True) 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) # rdf+xml is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # rdf+xml is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinRDFXML_Conneg(self): result = self.__generic(describeQuery, RDFXML, POST, onlyConneg=True) 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) # turtle is not a valid alias def testDescribeByGETinTURTLE(self): result = self.__generic(describeQuery, TURTLE, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # turtle is not a valid alias def testDescribeByGETinTURTLE_Conneg(self): result = self.__generic(describeQuery, TURTLE, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # turtle is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinTURTLE(self): result = self.__generic(describeQuery, TURTLE, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # turtle is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinTURTLE_Conneg(self): result = self.__generic(describeQuery, TURTLE, POST, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _RDF_TURTLE], ct results = result.convert() self.assertEqual(type(results), bytes) # n3 is not a valid alias 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) # n3 is not a valid alias def testDescribeByGETinN3_Conneg(self): result = self.__generic(describeQuery, N3, GET, onlyConneg=True) 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) # n3 is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # n3 is not a valid alias @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinN3_Conneg(self): result = self.__generic(describeQuery, N3, POST, onlyConneg=True) 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 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) def testDescribeByGETinJSONLD_Conneg(self): result = self.__generic(describeQuery, JSONLD, GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinJSONLD_Conneg(self): result = self.__generic(describeQuery, JSONLD, POST, onlyConneg=True) 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. # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle def testDescribeByGETinCSV_Unexpected(self): result = self.__generic(describeQuery, CSV, GET) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() 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 text/turtle def testDescribeByGETinCSV_Unexpected_Conneg(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] results = result.convert() 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 text/turtle @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinCSV_Unexpected(self): result = self.__generic(describeQuery, CSV, POST) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # Asking for an unexpected return format for DESCRIBE queryType. # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinCSV_Unexpected_Conneg(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] results = result.convert() 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 text/turtle # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) def testDescribeByGETinJSON_Unexpected(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] results = result.convert() 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 text/turtle def testDescribeByGETinJSON_Unexpected_Conneg(self): result = self.__generic(describeQuery, JSON, GET, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() 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 text/turtle # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinJSON_Unexpected(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] results = result.convert() self.assertEqual(type(results), ConjunctiveGraph) # Asking for an unexpected return format for DESCRIBE queryType. # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinJSON_Unexpected_Conneg(self): result = self.__generic(describeQuery, JSON, POST, onlyConneg=True) ct = result.info()["content-type"] assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] results = result.convert() 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 testDescribeByGETinUnknow_Conneg(self): result = self.__generic(describeQuery, "foo", GET, onlyConneg=True) 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) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) 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) # Asking for an unknown return format for DESCRIBE queryType (XML is sent) @unittest.skip( "The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki" ) def testDescribeByPOSTinUnknow_Conneg(self): result = self.__generic(describeQuery, "bar", POST, onlyConneg=True) 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) ################################################################################ ################################################################################ @unittest.skip( "Fuseki returns 200 instead of 400 (error code present in the returned text response)" ) 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("Line 10, column 40: Illegal prefix name escape: _. See #94") @unittest.skip( "Fuseki returns 200 instead of 400 (error code present in the returned text response)" ) def testQueryWithComma_1(self): result = self.__generic(queryWithCommaInCurie_1, XML, GET) @unittest.skip( 'Lexical error at line 10, column 45. Encountered: ":" (58), after : "\\". See #94' ) @unittest.skip( "Fuseki returns 200 instead of 400 (error code present in the returned text response)" ) def testQueryWithComma_2(self): result = self.__generic(queryWithCommaInCurie_2, XML, GET) def testQueryWithComma_3(self): result = self.__generic(queryWithCommaInUri, XML, GET) if __name__ == "__main__": unittest.main()