1# -*- coding: utf-8 -*- 2#!/usr/bin/python 3 4import inspect 5import os 6import sys 7import unittest 8 9# prefer local copy to the one which is installed 10# hack from http://stackoverflow.com/a/6098238/280539 11_top_level_path = os.path.realpath(os.path.abspath(os.path.join( 12 os.path.split(inspect.getfile(inspect.currentframe()))[0], 13 ".." 14))) 15if _top_level_path not in sys.path: 16 sys.path.insert(0, _top_level_path) 17# end of hack 18 19import warnings 20warnings.simplefilter("always") 21 22try: 23 from rdflib.graph import ConjunctiveGraph 24except ImportError: 25 from rdflib import ConjunctiveGraph 26 27from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET 28from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV 29from SPARQLWrapper.SPARQLExceptions import QueryBadFormed 30 31_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test 32_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE 33 34try: 35 from urllib.error import HTTPError # Python 3 36except ImportError: 37 from urllib2 import HTTPError # Python 2 38 39try: 40 bytes # Python 2.6 and above 41except NameError: 42 bytes = str 43 44import logging 45logging.basicConfig() 46 47endpoint = "https://lov.linkeddata.es/dataset/lov/sparql/" # Fuseki - version 1.1.1 (Build date: 2014-10-02T16:36:17+0100) 48 49prefixes = """ 50 PREFIX vann:<http://purl.org/vocab/vann/> 51 PREFIX voaf:<http://purl.org/vocommons/voaf#> 52 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 53 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 54 PREFIX skos: <http://www.w3.org/2004/02/skos/core#> 55""" 56 57selectQuery = """ 58 SELECT DISTINCT ?vocabPrefix ?vocabURI { 59 GRAPH <https://lov.linkeddata.es/dataset/lov>{ 60 ?vocabURI a voaf:Vocabulary. 61 ?vocabURI vann:preferredNamespacePrefix ?vocabPrefix. 62 }} ORDER BY ?vocabPrefix 63""" 64 65selectQueryCSV_TSV = """ 66 SELECT DISTINCT ?vocabPrefix ?vocabURI { 67 GRAPH <https://lov.linkeddata.es/dataset/lov>{ 68 ?vocabURI a voaf:Vocabulary. 69 ?vocabURI vann:preferredNamespacePrefix ?vocabPrefix. 70 }} ORDER BY ?vocabPrefix 71""" 72askQuery = """ 73 ASK { <http://xmlns.com/foaf/0.1/> a <http://purl.org/vocommons/voaf#Vocabulary> } 74""" 75 76constructQuery = """ 77 CONSTRUCT { 78 _:v skos:prefLabel ?label . 79 _:v rdfs:comment "this is only a mock node to test library" 80 } 81 WHERE { 82 <http://xmlns.com/foaf/0.1/> rdfs:label ?label . 83 } 84""" 85 86describeQuery = """ 87 DESCRIBE <http://xmlns.com/foaf/0.1/> 88""" 89 90queryBadFormed = """ 91 PREFIX prop: <http://dbpedia.org/property/> 92 PREFIX res: <http://dbpedia.org/resource/> 93 FROM <http://dbpedia.org/sparql?default-graph-uri=http%3A%2F%2Fdbpedia.org&should-sponge=&query=%0D%0ACONSTRUCT+%7B%0D%0A++++%3Chttp%3A%2F%2Fdbpedia.org%2Fresource%2FBudapest%3E+%3Fp+%3Fo.%0D%0A%7D%0D%0AWHERE+%7B%0D%0A++++%3Chttp%3A%2F%2Fdbpedia.org%2Fresource%2FBudapest%3E+%3Fp+%3Fo.%0D%0A%7D%0D%0A&format=application%2Frdf%2Bxml> 94 SELECT ?lat ?long 95 WHERE { 96 res:Budapest prop:latitude ?lat; 97 prop:longitude ?long. 98 } 99""" 100 101queryManyPrefixes = """ 102 PREFIX conf: <http://richard.cyganiak.de/2007/pubby/config.rdf#> 103 PREFIX meta: <http://example.org/metadata#> 104 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 105 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 106 PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> 107 PREFIX owl: <http://www.w3.org/2002/07/owl#> 108 PREFIX dc: <http://purl.org/dc/elements/1.1/> 109 PREFIX dcterms: <http://purl.org/dc/terms/> 110 PREFIX foaf: <http://xmlns.com/foaf/0.1/> 111 PREFIX skos: <http://www.w3.org/2004/02/skos/core#> 112 PREFIX geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> 113 PREFIX dbpedia: <http://dbpedia.org/resource/> 114 PREFIX o: <http://dbpedia.org/ontology/> 115 PREFIX p: <http://dbpedia.org/property/> 116 PREFIX yago: <http://dbpedia.org/class/yago/> 117 PREFIX units: <http://dbpedia.org/units/> 118 PREFIX geonames: <http://www.geonames.org/ontology#> 119 PREFIX prv: <http://purl.org/net/provenance/ns#> 120 PREFIX prvTypes: <http://purl.org/net/provenance/types#> 121 PREFIX foo: <http://purl.org/foo> 122 123 SELECT ?label 124 WHERE { 125 <http://dbpedia.org/resource/Asturias> rdfs:label ?label . 126 } 127""" 128 129queryDuplicatedPrefix = """ 130 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 131 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 132 133 SELECT ?s ?p ?o WHERE { 134 ?s ?p ?o . 135 } LIMIT 10 136""" 137 138queryWithCommaInCurie_1 = """ 139 PREFIX dbpedia: <http://dbpedia.org/resource/> 140 SELECT ?article ?title WHERE { 141 ?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia . 142 ?article <http://xmlns.com/foaf/0.1/isPrimaryTopicOf> ?title 143 } 144""" 145 146queryWithCommaInCurie_2 = """ 147 PREFIX dbpedia: <http://dbpedia.org/resource/> 148 SELECT ?article ?title WHERE { 149 ?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia . 150 ?article <http://xmlns.com/foaf/0.1/isPrimaryTopicOf> ?title 151 } 152""" 153 154queryWithCommaInUri = """ 155 SELECT ?article ?title WHERE { 156 ?article ?relation <http://dbpedia.org/resource/Category:Victoria,_British_Columbia> . 157 ?article <http://xmlns.com/foaf/0.1/isPrimaryTopicOf> ?title 158 } 159""" 160 161class SPARQLWrapperTests(unittest.TestCase): 162 163 def __generic(self, query, returnFormat, method, onlyConneg=False): # Fuseki uses URL parameters. 164 sparql = SPARQLWrapper(endpoint) 165 sparql.setQuery(prefixes + query) 166 sparql.setReturnFormat(returnFormat) 167 sparql.setMethod(method) 168 sparql.setOnlyConneg(onlyConneg) 169 try: 170 result = sparql.query() 171 except HTTPError: 172 # An ugly way to get the exception, but the only one that works 173 # both on Python 2.5 and Python 3. 174 e = sys.exc_info()[1] 175 if e.code == 400: 176 sys.stdout.write("400 Bad Request, probably query is not well formed") 177 elif e.code == 406: 178 sys.stdout.write("406 Not Acceptable, maybe query is not well formed") 179 else: 180 sys.stdout.write(str(e)) 181 sys.stdout.write("\n") 182 return False 183 else: 184 return result 185 186 187################################################################################ 188################################################################################ 189 190################ 191#### SELECT #### 192################ 193 194 def testSelectByGETinXML(self): 195 result = self.__generic(selectQuery, XML, GET) 196 ct = result.info()["content-type"] 197 assert True in [one in ct for one in _SPARQL_XML], ct 198 results = result.convert() 199 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 200 self.assertEqual(results.__class__.__name__, "Document") 201 202 def testSelectByGETinXML_Conneg(self): 203 result = self.__generic(selectQuery, XML, GET, onlyConneg=True) 204 ct = result.info()["content-type"] 205 assert True in [one in ct for one in _SPARQL_XML], ct 206 results = result.convert() 207 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 208 self.assertEqual(results.__class__.__name__, "Document") 209 210 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 211 def testSelectByPOSTinXML(self): 212 result = self.__generic(selectQuery, XML, POST) 213 ct = result.info()["content-type"] 214 assert True in [one in ct for one in _SPARQL_XML], ct 215 results = result.convert() 216 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 217 self.assertEqual(results.__class__.__name__, "Document") 218 219 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 220 def testSelectByPOSTinXML_Conneg(self): 221 result = self.__generic(selectQuery, XML, POST, onlyConneg=True) 222 ct = result.info()["content-type"] 223 assert True in [one in ct for one in _SPARQL_XML], ct 224 results = result.convert() 225 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 226 self.assertEqual(results.__class__.__name__, "Document") 227 228 def testSelectByGETinCSV(self): 229 result = self.__generic(selectQueryCSV_TSV, CSV, GET) 230 ct = result.info()["content-type"] 231 assert True in [one in ct for one in _CSV], ct 232 results = result.convert() 233 self.assertEqual(type(results), bytes) 234 235 def testSelectByGETinCSV_Conneg(self): 236 result = self.__generic(selectQueryCSV_TSV, CSV, GET, onlyConneg=True) 237 ct = result.info()["content-type"] 238 assert True in [one in ct for one in _CSV], ct 239 results = result.convert() 240 self.assertEqual(type(results), bytes) 241 242 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 243 def testSelectByPOSTinCSV(self): 244 result = self.__generic(selectQueryCSV_TSV, CSV, POST) 245 ct = result.info()["content-type"] 246 assert True in [one in ct for one in _CSV], ct 247 results = result.convert() 248 self.assertEqual(type(results), bytes) 249 250 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 251 def testSelectByPOSTinCSV_Conneg(self): 252 result = self.__generic(selectQueryCSV_TSV, CSV, POST, onlyConneg=True) 253 ct = result.info()["content-type"] 254 assert True in [one in ct for one in _CSV], ct 255 results = result.convert() 256 self.assertEqual(type(results), bytes) 257 258 def testSelectByGETinTSV(self): 259 result = self.__generic(selectQueryCSV_TSV, TSV, GET) 260 ct = result.info()["content-type"] 261 assert True in [one in ct for one in _TSV], ct 262 results = result.convert() 263 self.assertEqual(type(results), bytes) 264 265 def testSelectByGETinTSV_Conneg(self): 266 result = self.__generic(selectQueryCSV_TSV, TSV, GET, onlyConneg=True) 267 ct = result.info()["content-type"] 268 assert True in [one in ct for one in _TSV], ct 269 results = result.convert() 270 self.assertEqual(type(results), bytes) 271 272 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 273 def testSelectByPOSTinTSV(self): 274 result = self.__generic(selectQueryCSV_TSV, TSV, POST) 275 ct = result.info()["content-type"] 276 assert True in [one in ct for one in _TSV], ct 277 results = result.convert() 278 self.assertEqual(type(results), bytes) 279 280 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 281 def testSelectByPOSTinTSV_Conneg(self): 282 result = self.__generic(selectQueryCSV_TSV, TSV, POST, onlyConneg=True) 283 ct = result.info()["content-type"] 284 assert True in [one in ct for one in _TSV], ct 285 results = result.convert() 286 self.assertEqual(type(results), bytes) 287 288 def testSelectByGETinJSON(self): 289 result = self.__generic(selectQuery, JSON, GET) 290 ct = result.info()["content-type"] 291 assert True in [one in ct for one in _SPARQL_JSON], ct 292 results = result.convert() 293 self.assertEqual(type(results), dict) 294 295 def testSelectByGETinJSON_Conneg(self): 296 result = self.__generic(selectQuery, JSON, GET, onlyConneg=True) 297 ct = result.info()["content-type"] 298 assert True in [one in ct for one in _SPARQL_JSON], ct 299 results = result.convert() 300 self.assertEqual(type(results), dict) 301 302 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 303 def testSelectByPOSTinJSON(self): 304 result = self.__generic(selectQuery, JSON, POST) 305 ct = result.info()["content-type"] 306 assert True in [one in ct for one in _SPARQL_JSON], ct 307 results = result.convert() 308 self.assertEqual(type(results), dict) 309 310 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 311 def testSelectByPOSTinJSON_Conneg(self): 312 result = self.__generic(selectQuery, JSON, POST, onlyConneg=True) 313 ct = result.info()["content-type"] 314 assert True in [one in ct for one in _SPARQL_JSON], ct 315 results = result.convert() 316 self.assertEqual(type(results), dict) 317 318 # Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). 319 # Set by default None (and sending */*). 320 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 321 def testSelectByGETinN3_Unexpected(self): 322 result = self.__generic(selectQuery, N3, GET) 323 ct = result.info()["content-type"] 324 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 325 results = result.convert() 326 self.assertEqual(type(results), dict) 327 328 # Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). 329 # Set by default None (and sending */*). 330 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 331 def testSelectByGETinN3_Unexpected_Conneg(self): 332 result = self.__generic(selectQuery, N3, GET, onlyConneg=True) 333 ct = result.info()["content-type"] 334 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 335 results = result.convert() 336 self.assertEqual(type(results), dict) 337 338 # Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). 339 # Set by default None (and sending */*). 340 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 341 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 342 def testSelectByPOSTinN3_Unexpected(self): 343 result = self.__generic(selectQuery, N3, POST) 344 ct = result.info()["content-type"] 345 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 346 results = result.convert() 347 self.assertEqual(type(results), dict) 348 349 # Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias). 350 # Set by default None (and sending */*). 351 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 352 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 353 def testSelectByPOSTinN3_Unexpected_Conneg(self): 354 result = self.__generic(selectQuery, N3, POST, onlyConneg=True) 355 ct = result.info()["content-type"] 356 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 357 results = result.convert() 358 self.assertEqual(type(results), dict) 359 360 # Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). 361 # Set by default None (and sending */*). 362 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 363 def testSelectByGETinJSONLD_Unexpected(self): 364 result = self.__generic(selectQuery, JSONLD, GET) 365 ct = result.info()["content-type"] 366 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 367 results = result.convert() 368 self.assertEqual(type(results), dict) 369 370 # Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). 371 # Set by default None (and sending */*). 372 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 373 def testSelectByGETinJSONLD_Unexpected_Conneg(self): 374 result = self.__generic(selectQuery, JSONLD, GET, onlyConneg=True) 375 ct = result.info()["content-type"] 376 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 377 results = result.convert() 378 self.assertEqual(type(results), dict) 379 380 # Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). 381 # Set by default None (and sending */*). 382 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 383 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 384 def testSelectByPOSTinJSONLD_Unexpected(self): 385 result = self.__generic(selectQuery, JSONLD, POST) 386 ct = result.info()["content-type"] 387 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 388 results = result.convert() 389 self.assertEqual(type(results), dict) 390 391 # Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias). 392 # Set by default None (and sending */*). 393 # For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 394 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 395 def testSelectByPOSTinJSONLD_Unexpected_Conneg(self): 396 result = self.__generic(selectQuery, JSONLD, POST, onlyConneg=True) 397 ct = result.info()["content-type"] 398 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 399 results = result.convert() 400 self.assertEqual(type(results), dict) 401 402 # Asking for an unknown return format for SELECT queryType (XML is sent) 403 def testSelectByGETinUnknow(self): 404 result = self.__generic(selectQuery, "foo", GET) 405 ct = result.info()["content-type"] 406 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 407 results = result.convert() 408 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 409 self.assertEqual(results.__class__.__name__, "Document") 410 411 # Asking for an unknown return format for SELECT queryType (XML is sent) 412 def testSelectByGETinUnknow_Conneg(self): 413 result = self.__generic(selectQuery, "foo", GET, onlyConneg=True) 414 ct = result.info()["content-type"] 415 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 416 results = result.convert() 417 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 418 self.assertEqual(results.__class__.__name__, "Document") 419 420 # Asking for an unknown return format for SELECT queryType (XML is sent) 421 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 422 def testSelectByPOSTinUnknow(self): 423 result = self.__generic(selectQuery, "bar", POST) 424 ct = result.info()["content-type"] 425 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 426 results = result.convert() 427 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 428 self.assertEqual(results.__class__.__name__, "Document") 429 430 # Asking for an unknown return format for SELECT queryType (XML is sent) 431 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 432 def testSelectByPOSTinUnknow_Conneg(self): 433 result = self.__generic(selectQuery, "bar", POST, onlyConneg=True) 434 ct = result.info()["content-type"] 435 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 436 results = result.convert() 437 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 438 self.assertEqual(results.__class__.__name__, "Document") 439 440################################################################################ 441################################################################################ 442 443############# 444#### ASK #### 445############# 446 447 def testAskByGETinXML(self): 448 result = self.__generic(askQuery, XML, GET) 449 ct = result.info()["content-type"] 450 assert True in [one in ct for one in _SPARQL_XML], ct 451 results = result.convert() 452 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 453 self.assertEqual(results.__class__.__name__, "Document") 454 455 def testAskByGETinXML_Conneg(self): 456 result = self.__generic(askQuery, XML, GET, onlyConneg=True) 457 ct = result.info()["content-type"] 458 assert True in [one in ct for one in _SPARQL_XML], ct 459 results = result.convert() 460 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 461 self.assertEqual(results.__class__.__name__, "Document") 462 463 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 464 def testAskByPOSTinXML(self): 465 result = self.__generic(askQuery, XML, POST) 466 ct = result.info()["content-type"] 467 assert True in [one in ct for one in _SPARQL_XML], ct 468 results = result.convert() 469 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 470 self.assertEqual(results.__class__.__name__, "Document") 471 472 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 473 def testAskByPOSTinXML_Conneg(self): 474 result = self.__generic(askQuery, XML, POST, onlyConneg=True) 475 ct = result.info()["content-type"] 476 assert True in [one in ct for one in _SPARQL_XML], ct 477 results = result.convert() 478 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 479 self.assertEqual(results.__class__.__name__, "Document") 480 481 def testAskByGETinCSV(self): 482 result = self.__generic(askQuery, CSV, GET) 483 ct = result.info()["content-type"] 484 assert True in [one in ct for one in _CSV], ct 485 results = result.convert() 486 self.assertEqual(type(results), bytes) 487 488 def testAskByGETinCSV_Conneg(self): 489 result = self.__generic(askQuery, CSV, GET, onlyConneg=True) 490 ct = result.info()["content-type"] 491 assert True in [one in ct for one in _CSV], ct 492 results = result.convert() 493 self.assertEqual(type(results), bytes) 494 495 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 496 def testAskByPOSTinCSV(self): 497 result = self.__generic(askQuery, CSV, POST) 498 ct = result.info()["content-type"] 499 assert True in [one in ct for one in _CSV], ct 500 results = result.convert() 501 self.assertEqual(type(results), bytes) 502 503 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 504 def testAskByPOSTinCSV_Conneg(self): 505 result = self.__generic(askQuery, CSV, POST, onlyConneg=True) 506 ct = result.info()["content-type"] 507 assert True in [one in ct for one in _CSV], ct 508 results = result.convert() 509 self.assertEqual(type(results), bytes) 510 511 def testAskByGETinTSV(self): 512 result = self.__generic(askQuery, TSV, GET) 513 ct = result.info()["content-type"] 514 assert True in [one in ct for one in _TSV], ct 515 results = result.convert() 516 self.assertEqual(type(results), bytes) 517 518 def testAskByGETinTSV_Conneg(self): 519 result = self.__generic(askQuery, TSV, GET, onlyConneg=True) 520 ct = result.info()["content-type"] 521 assert True in [one in ct for one in _TSV], ct 522 results = result.convert() 523 self.assertEqual(type(results), bytes) 524 525 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 526 def testAskByPOSTinTSV(self): 527 result = self.__generic(askQuery, TSV, POST) 528 ct = result.info()["content-type"] 529 assert True in [one in ct for one in _TSV], ct 530 results = result.convert() 531 self.assertEqual(type(results), bytes) 532 533 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 534 def testAskByPOSTinTSV_Conneg(self): 535 result = self.__generic(askQuery, TSV, POST, onlyConneg=True) 536 ct = result.info()["content-type"] 537 assert True in [one in ct for one in _TSV], ct 538 results = result.convert() 539 self.assertEqual(type(results), bytes) 540 541 def testAskByGETinJSON(self): 542 result = self.__generic(askQuery, JSON, GET) 543 ct = result.info()["content-type"] 544 assert True in [one in ct for one in _SPARQL_JSON], ct 545 results = result.convert() 546 self.assertEqual(type(results), dict) 547 548 def testAskByGETinJSON_Conneg(self): 549 result = self.__generic(askQuery, JSON, GET, onlyConneg=True) 550 ct = result.info()["content-type"] 551 assert True in [one in ct for one in _SPARQL_JSON], ct 552 results = result.convert() 553 self.assertEqual(type(results), dict) 554 555 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 556 def testAskByPOSTinJSON(self): 557 result = self.__generic(askQuery, JSON, POST) 558 ct = result.info()["content-type"] 559 assert True in [one in ct for one in _SPARQL_JSON], ct 560 results = result.convert() 561 self.assertEqual(type(results), dict) 562 563 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 564 def testAskByPOSTinJSON_Conneg(self): 565 result = self.__generic(askQuery, JSON, POST, onlyConneg=True) 566 ct = result.info()["content-type"] 567 assert True in [one in ct for one in _SPARQL_JSON], ct 568 results = result.convert() 569 self.assertEqual(type(results), dict) 570 571 # Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). 572 # Set by default None (and sending */*). 573 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 574 def testAskByGETinN3_Unexpected(self): 575 result = self.__generic(askQuery, N3, GET) 576 ct = result.info()["content-type"] 577 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 578 results = result.convert() 579 self.assertEqual(type(results), dict) 580 581 # Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). 582 # Set by default None (and sending */*). 583 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 584 def testAskByGETinN3_Unexpected_Conneg(self): 585 result = self.__generic(askQuery, N3, GET, onlyConneg=True) 586 ct = result.info()["content-type"] 587 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 588 results = result.convert() 589 self.assertEqual(type(results), dict) 590 591 # Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). 592 # Set by default None (and sending */*). 593 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 594 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 595 def testAskByPOSTinN3_Unexpected(self): 596 result = self.__generic(askQuery, N3, POST) 597 ct = result.info()["content-type"] 598 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 599 results = result.convert() 600 self.assertEqual(type(results), dict) 601 602 # Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias). 603 # Set by default None (and sending */*). 604 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 605 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 606 def testAskByPOSTinN3_Unexpected_Conneg(self): 607 result = self.__generic(askQuery, N3, POST, onlyConneg=True) 608 ct = result.info()["content-type"] 609 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 610 results = result.convert() 611 self.assertEqual(type(results), dict) 612 613 # Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). 614 # Set by default None (and sending */*). 615 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 616 def testAskByGETinJSONLD_Unexpected(self): 617 result = self.__generic(askQuery, JSONLD, GET) 618 ct = result.info()["content-type"] 619 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 620 results = result.convert() 621 self.assertEqual(type(results), dict) 622 623 # Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). 624 # Set by default None (and sending */*). 625 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 626 def testAskByGETinJSONLD_Unexpected_Conneg(self): 627 result = self.__generic(askQuery, JSONLD, GET, onlyConneg=True) 628 ct = result.info()["content-type"] 629 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 630 results = result.convert() 631 self.assertEqual(type(results), dict) 632 633 # Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). 634 # Set by default None (and sending */*). 635 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 636 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 637 def testAskByPOSTinJSONLD_Unexpected(self): 638 result = self.__generic(askQuery, JSONLD, POST) 639 ct = result.info()["content-type"] 640 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 641 results = result.convert() 642 self.assertEqual(type(results), dict) 643 644 # Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias). 645 # Set by default None (and sending */*). 646 # For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json 647 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 648 def testAskByPOSTinJSONLD_Unexpected_Conneg(self): 649 result = self.__generic(askQuery, JSONLD, POST, onlyConneg=True) 650 ct = result.info()["content-type"] 651 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 652 results = result.convert() 653 self.assertEqual(type(results), dict) 654 655 # Asking for an unknown return format for ASK queryType (XML is sent) 656 def testAskByGETinUnknow(self): 657 result = self.__generic(askQuery, "foo", GET) 658 ct = result.info()["content-type"] 659 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 660 results = result.convert() 661 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 662 self.assertEqual(results.__class__.__name__, "Document") 663 664 # Asking for an unknown return format for ASK queryType (XML is sent) 665 def testAskByGETinUnknow_Conneg(self): 666 result = self.__generic(askQuery, "foo", GET, onlyConneg=True) 667 ct = result.info()["content-type"] 668 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 669 results = result.convert() 670 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 671 self.assertEqual(results.__class__.__name__, "Document") 672 673 # Asking for an unknown return format for ASK queryType (XML is sent) 674 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 675 def testAskByPOSTinUnknow(self): 676 result = self.__generic(askQuery, "bar", POST) 677 ct = result.info()["content-type"] 678 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 679 results = result.convert() 680 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 681 self.assertEqual(results.__class__.__name__, "Document") 682 683 # Asking for an unknown return format for ASK queryType (XML is sent) 684 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 685 def testAskByPOSTinUnknow_Conneg(self): 686 result = self.__generic(askQuery, "bar", POST, onlyConneg=True) 687 ct = result.info()["content-type"] 688 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 689 results = result.convert() 690 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 691 self.assertEqual(results.__class__.__name__, "Document") 692 693################################################################################ 694################################################################################ 695 696################### 697#### CONSTRUCT #### 698################### 699 700 def testConstructByGETinXML(self): 701 result = self.__generic(constructQuery, XML, GET) 702 ct = result.info()["content-type"] 703 assert True in [one in ct for one in _RDF_XML], ct 704 results = result.convert() 705 self.assertEqual(type(results), ConjunctiveGraph) 706 707 def testConstructByGETinXML_Conneg(self): 708 result = self.__generic(constructQuery, XML, GET, onlyConneg=True) 709 ct = result.info()["content-type"] 710 assert True in [one in ct for one in _RDF_XML], ct 711 results = result.convert() 712 self.assertEqual(type(results), ConjunctiveGraph) 713 714 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 715 def testConstructByPOSTinXML(self): 716 result = self.__generic(constructQuery, XML, POST) 717 ct = result.info()["content-type"] 718 assert True in [one in ct for one in _RDF_XML], ct 719 results = result.convert() 720 self.assertEqual(type(results), ConjunctiveGraph) 721 722 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 723 def testConstructByPOSTinXML_Conneg(self): 724 result = self.__generic(constructQuery, XML, POST, onlyConneg=True) 725 ct = result.info()["content-type"] 726 assert True in [one in ct for one in _RDF_XML], ct 727 results = result.convert() 728 self.assertEqual(type(results), ConjunctiveGraph) 729 730 # rdf+xml is not a valid alias 731 def testConstructByGETinRDFXML(self): 732 result = self.__generic(constructQuery, RDFXML, GET) 733 ct = result.info()["content-type"] 734 assert True in [one in ct for one in _RDF_XML], ct 735 results = result.convert() 736 self.assertEqual(type(results), ConjunctiveGraph) 737 738 # rdf+xml is not a valid alias 739 def testConstructByGETinRDFXML_Conneg(self): 740 result = self.__generic(constructQuery, RDFXML, GET, onlyConneg=True) 741 ct = result.info()["content-type"] 742 assert True in [one in ct for one in _RDF_XML], ct 743 results = result.convert() 744 self.assertEqual(type(results), ConjunctiveGraph) 745 746 # rdf+xml is not a valid alias 747 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 748 def testConstructByPOSTinRDFXML(self): 749 result = self.__generic(constructQuery, RDFXML, POST) 750 ct = result.info()["content-type"] 751 assert True in [one in ct for one in _RDF_XML], ct 752 results = result.convert() 753 self.assertEqual(type(results), ConjunctiveGraph) 754 755 # rdf+xml is not a valid alias 756 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 757 def testConstructByPOSTinRDFXML_Conneg(self): 758 result = self.__generic(constructQuery, RDFXML, POST, onlyConneg=True) 759 ct = result.info()["content-type"] 760 assert True in [one in ct for one in _RDF_XML], ct 761 results = result.convert() 762 self.assertEqual(type(results), ConjunctiveGraph) 763 764 # turtle is not a valid alias 765 def testConstructByGETinTURTLE(self): 766 result = self.__generic(constructQuery, TURTLE, GET) 767 ct = result.info()["content-type"] 768 assert True in [one in ct for one in _RDF_TURTLE], ct 769 results = result.convert() 770 self.assertEqual(type(results), bytes) 771 772 # turtle is not a valid alias 773 def testConstructByGETinTURTLE_Conneg(self): 774 result = self.__generic(constructQuery, TURTLE, GET, onlyConneg=True) 775 ct = result.info()["content-type"] 776 assert True in [one in ct for one in _RDF_TURTLE], ct 777 results = result.convert() 778 self.assertEqual(type(results), bytes) 779 780 # turtle is not a valid alias 781 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 782 def testConstructByPOSTinTURTLE(self): 783 result = self.__generic(constructQuery, TURTLE, POST) 784 ct = result.info()["content-type"] 785 assert True in [one in ct for one in _RDF_TURTLE], ct 786 results = result.convert() 787 self.assertEqual(type(results), bytes) 788 789 # turtle is not a valid alias 790 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 791 def testConstructByPOSTinTURTLE_Conneg(self): 792 result = self.__generic(constructQuery, TURTLE, POST, onlyConneg=True) 793 ct = result.info()["content-type"] 794 assert True in [one in ct for one in _RDF_TURTLE], ct 795 results = result.convert() 796 self.assertEqual(type(results), bytes) 797 798 # n3 is not a valid alias 799 def testConstructByGETinN3(self): 800 result = self.__generic(constructQuery, N3, GET) 801 ct = result.info()["content-type"] 802 assert True in [one in ct for one in _RDF_N3], ct 803 results = result.convert() 804 self.assertEqual(type(results), bytes) 805 806 # n3 is not a valid alias 807 def testConstructByGETinN3_Conneg(self): 808 result = self.__generic(constructQuery, N3, GET, onlyConneg=True) 809 ct = result.info()["content-type"] 810 assert True in [one in ct for one in _RDF_N3], ct 811 results = result.convert() 812 self.assertEqual(type(results), bytes) 813 814 # n3 is not a valid alias 815 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 816 def testConstructByPOSTinN3(self): 817 result = self.__generic(constructQuery, N3, POST) 818 ct = result.info()["content-type"] 819 assert True in [one in ct for one in _RDF_N3], ct 820 results = result.convert() 821 self.assertEqual(type(results), bytes) 822 823 # n3 is not a valid alias 824 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 825 def testConstructByPOSTinN3_Conneg(self): 826 result = self.__generic(constructQuery, N3, POST, onlyConneg=True) 827 ct = result.info()["content-type"] 828 assert True in [one in ct for one in _RDF_N3], ct 829 results = result.convert() 830 self.assertEqual(type(results), bytes) 831 832 # json-ld is not a valid alias. Use content negotiation instead 833 def testConstructByGETinJSONLD(self): 834 result = self.__generic(constructQuery, JSONLD, GET) 835 ct = result.info()["content-type"] 836 assert True in [one in ct for one in _RDF_JSONLD], ct 837 results = result.convert() 838 self.assertEqual(type(results), ConjunctiveGraph) 839 840 # json-ld is not a valid alias. Use content negotiation instead 841 def testConstructByGETinJSONLD_Conneg(self): 842 result = self.__generic(constructQuery, JSONLD, GET, onlyConneg=True) 843 ct = result.info()["content-type"] 844 assert True in [one in ct for one in _RDF_JSONLD], ct 845 results = result.convert() 846 self.assertEqual(type(results), ConjunctiveGraph) 847 848 # json-ld is not a valid alias. Use content negotiation instead 849 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 850 def testConstructByPOSTinJSONLD(self): 851 result = self.__generic(constructQuery, JSONLD, POST) 852 ct = result.info()["content-type"] 853 assert True in [one in ct for one in _RDF_JSONLD], ct 854 results = result.convert() 855 self.assertEqual(type(results), ConjunctiveGraph) 856 857 # json-ld is not a valid alias. Use content negotiation instead 858 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 859 def testConstructByPOSTinJSONLD_Conneg(self): 860 result = self.__generic(constructQuery, JSONLD, POST, onlyConneg=True) 861 ct = result.info()["content-type"] 862 assert True in [one in ct for one in _RDF_JSONLD], ct 863 results = result.convert() 864 self.assertEqual(type(results), ConjunctiveGraph) 865 866 # Asking for an unexpected return format for CONSTRUCT queryType. 867 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 868 def testConstructByGETinCSV_Unexpected(self): 869 result = self.__generic(constructQuery, CSV, GET) 870 ct = result.info()["content-type"] 871 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 872 results = result.convert() 873 self.assertEqual(type(results), bytes) 874 875 # Asking for an unexpected return format for CONSTRUCT queryType. 876 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 877 def testConstructByGETinCSV_Unexpected_Conneg(self): 878 result = self.__generic(constructQuery, CSV, GET, onlyConneg=True) 879 ct = result.info()["content-type"] 880 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 881 results = result.convert() 882 self.assertEqual(type(results), bytes) 883 884 # Asking for an unexpected return format for CONSTRUCT queryType. 885 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 886 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 887 def testConstructByPOSTinCSV_Unexpected(self): 888 result = self.__generic(constructQuery, CSV, POST) 889 ct = result.info()["content-type"] 890 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 891 results = result.convert() 892 self.assertEqual(type(results), bytes) 893 894 # Asking for an unexpected return format for CONSTRUCT queryType. 895 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 896 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 897 def testConstructByPOSTinCSV_Unexpected_Conneg(self): 898 result = self.__generic(constructQuery, CSV, POST, onlyConneg=True) 899 ct = result.info()["content-type"] 900 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 901 results = result.convert() 902 self.assertEqual(type(results), bytes) 903 904 # Asking for an unexpected return format for CONSTRUCT queryType. 905 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 906 # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) 907 def testConstructByGETinJSON_Unexpected(self): 908 result = self.__generic(constructQuery, JSON, GET) 909 ct = result.info()["content-type"] 910 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 911 results = result.convert() 912 self.assertEqual(type(results), bytes) 913 914 # Asking for an unexpected return format for CONSTRUCT queryType. 915 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 916 def testConstructByGETinJSON_Unexpected_Conneg(self): 917 result = self.__generic(constructQuery, JSON, GET , onlyConneg=True) 918 ct = result.info()["content-type"] 919 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 920 results = result.convert() 921 self.assertEqual(type(results), bytes) 922 923 # Asking for an unexpected return format for CONSTRUCT queryType. 924 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 925 # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) 926 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 927 def testConstructByPOSTinJSON_Unexpected(self): 928 result = self.__generic(constructQuery, JSON, POST) 929 ct = result.info()["content-type"] 930 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 931 results = result.convert() 932 self.assertEqual(type(results), ConjunctiveGraph) 933 934 # Asking for an unexpected return format for CONSTRUCT queryType. 935 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 936 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 937 def testConstructByPOSTinJSON_Unexpected_Conneg(self): 938 result = self.__generic(constructQuery, JSON, POST, onlyConneg=True) 939 ct = result.info()["content-type"] 940 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 941 results = result.convert() 942 self.assertEqual(type(results), bytes) 943 944 # Asking for an unknown return format for CONSTRUCT queryType (XML is sent) 945 def testConstructByGETinUnknow(self): 946 result = self.__generic(constructQuery, "foo", GET) 947 ct = result.info()["content-type"] 948 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 949 results = result.convert() 950 self.assertEqual(type(results), ConjunctiveGraph) 951 952 # Asking for an unknown return format for CONSTRUCT queryType (XML is sent) 953 def testConstructByGETinUnknow_Conneg(self): 954 result = self.__generic(constructQuery, "foo", GET, onlyConneg=True) 955 ct = result.info()["content-type"] 956 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 957 results = result.convert() 958 self.assertEqual(type(results), ConjunctiveGraph) 959 960 # Asking for an unknown return format for CONSTRUCT queryType (XML is sent) 961 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 962 def testConstructByPOSTinUnknow(self): 963 result = self.__generic(constructQuery, "bar", POST) 964 ct = result.info()["content-type"] 965 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 966 results = result.convert() 967 self.assertEqual(type(results), ConjunctiveGraph) 968 969 # Asking for an unknown return format for CONSTRUCT queryType (XML is sent) 970 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 971 def testConstructByPOSTinUnknow_Conneg(self): 972 result = self.__generic(constructQuery, "bar", POST, onlyConneg=True) 973 ct = result.info()["content-type"] 974 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 975 results = result.convert() 976 self.assertEqual(type(results), ConjunctiveGraph) 977 978################################################################################ 979################################################################################ 980 981################## 982#### DESCRIBE #### 983################## 984 985 def testDescribeByGETinXML(self): 986 result = self.__generic(describeQuery, XML, GET) 987 ct = result.info()["content-type"] 988 assert True in [one in ct for one in _RDF_XML], ct 989 results = result.convert() 990 self.assertEqual(type(results), ConjunctiveGraph) 991 992 def testDescribeByGETinXML_Conneg(self): 993 result = self.__generic(describeQuery, XML, GET, onlyConneg=True) 994 ct = result.info()["content-type"] 995 assert True in [one in ct for one in _RDF_XML], ct 996 results = result.convert() 997 self.assertEqual(type(results), ConjunctiveGraph) 998 999 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1000 def testDescribeByPOSTinXML(self): 1001 result = self.__generic(describeQuery, XML, POST) 1002 ct = result.info()["content-type"] 1003 assert True in [one in ct for one in _RDF_XML], ct 1004 results = result.convert() 1005 self.assertEqual(type(results), ConjunctiveGraph) 1006 1007 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1008 def testDescribeByPOSTinXML_Conneg(self): 1009 result = self.__generic(describeQuery, XML, POST, onlyConneg=True) 1010 ct = result.info()["content-type"] 1011 assert True in [one in ct for one in _RDF_XML], ct 1012 results = result.convert() 1013 self.assertEqual(type(results), ConjunctiveGraph) 1014 1015 # rdf+xml is not a valid alias 1016 def testDescribeByGETinRDFXML(self): 1017 result = self.__generic(describeQuery, RDFXML, GET) 1018 ct = result.info()["content-type"] 1019 assert True in [one in ct for one in _RDF_XML], ct 1020 results = result.convert() 1021 self.assertEqual(type(results), ConjunctiveGraph) 1022 1023 # rdf+xml is not a valid alias 1024 def testDescribeByGETinRDFXML_Conneg(self): 1025 result = self.__generic(describeQuery, RDFXML, GET, onlyConneg=True) 1026 ct = result.info()["content-type"] 1027 assert True in [one in ct for one in _RDF_XML], ct 1028 results = result.convert() 1029 self.assertEqual(type(results), ConjunctiveGraph) 1030 1031 # rdf+xml is not a valid alias 1032 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1033 def testDescribeByPOSTinRDFXML(self): 1034 result = self.__generic(describeQuery, RDFXML, POST) 1035 ct = result.info()["content-type"] 1036 assert True in [one in ct for one in _RDF_XML], ct 1037 results = result.convert() 1038 self.assertEqual(type(results), ConjunctiveGraph) 1039 1040 # rdf+xml is not a valid alias 1041 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1042 def testDescribeByPOSTinRDFXML_Conneg(self): 1043 result = self.__generic(describeQuery, RDFXML, POST, onlyConneg=True) 1044 ct = result.info()["content-type"] 1045 assert True in [one in ct for one in _RDF_XML], ct 1046 results = result.convert() 1047 self.assertEqual(type(results), ConjunctiveGraph) 1048 1049 # turtle is not a valid alias 1050 def testDescribeByGETinTURTLE(self): 1051 result = self.__generic(describeQuery, TURTLE, GET) 1052 ct = result.info()["content-type"] 1053 assert True in [one in ct for one in _RDF_TURTLE], ct 1054 results = result.convert() 1055 self.assertEqual(type(results), bytes) 1056 1057 # turtle is not a valid alias 1058 def testDescribeByGETinTURTLE_Conneg(self): 1059 result = self.__generic(describeQuery, TURTLE, GET, onlyConneg=True) 1060 ct = result.info()["content-type"] 1061 assert True in [one in ct for one in _RDF_TURTLE], ct 1062 results = result.convert() 1063 self.assertEqual(type(results), bytes) 1064 1065 # turtle is not a valid alias 1066 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1067 def testDescribeByPOSTinTURTLE(self): 1068 result = self.__generic(describeQuery, TURTLE, POST) 1069 ct = result.info()["content-type"] 1070 assert True in [one in ct for one in _RDF_TURTLE], ct 1071 results = result.convert() 1072 self.assertEqual(type(results), bytes) 1073 1074 # turtle is not a valid alias 1075 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1076 def testDescribeByPOSTinTURTLE_Conneg(self): 1077 result = self.__generic(describeQuery, TURTLE, POST, onlyConneg=True) 1078 ct = result.info()["content-type"] 1079 assert True in [one in ct for one in _RDF_TURTLE], ct 1080 results = result.convert() 1081 self.assertEqual(type(results), bytes) 1082 1083 # n3 is not a valid alias 1084 def testDescribeByGETinN3(self): 1085 result = self.__generic(describeQuery, N3, GET) 1086 ct = result.info()["content-type"] 1087 assert True in [one in ct for one in _RDF_N3], ct 1088 results = result.convert() 1089 self.assertEqual(type(results), bytes) 1090 1091 # n3 is not a valid alias 1092 def testDescribeByGETinN3_Conneg(self): 1093 result = self.__generic(describeQuery, N3, GET, onlyConneg=True) 1094 ct = result.info()["content-type"] 1095 assert True in [one in ct for one in _RDF_N3], ct 1096 results = result.convert() 1097 self.assertEqual(type(results), bytes) 1098 1099 # n3 is not a valid alias 1100 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1101 def testDescribeByPOSTinN3(self): 1102 result = self.__generic(describeQuery, N3, POST) 1103 ct = result.info()["content-type"] 1104 assert True in [one in ct for one in _RDF_N3], ct 1105 results = result.convert() 1106 self.assertEqual(type(results), bytes) 1107 1108 # n3 is not a valid alias 1109 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1110 def testDescribeByPOSTinN3_Conneg(self): 1111 result = self.__generic(describeQuery, N3, POST, onlyConneg=True) 1112 ct = result.info()["content-type"] 1113 assert True in [one in ct for one in _RDF_N3], ct 1114 results = result.convert() 1115 self.assertEqual(type(results), bytes) 1116 1117 def testDescribeByGETinJSONLD(self): 1118 result = self.__generic(describeQuery, JSONLD, GET) 1119 ct = result.info()["content-type"] 1120 assert True in [one in ct for one in _RDF_JSONLD], ct 1121 results = result.convert() 1122 self.assertEqual(type(results), ConjunctiveGraph) 1123 1124 def testDescribeByGETinJSONLD_Conneg(self): 1125 result = self.__generic(describeQuery, JSONLD, GET, onlyConneg=True) 1126 ct = result.info()["content-type"] 1127 assert True in [one in ct for one in _RDF_JSONLD], ct 1128 results = result.convert() 1129 self.assertEqual(type(results), ConjunctiveGraph) 1130 1131 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1132 def testDescribeByPOSTinJSONLD(self): 1133 result = self.__generic(describeQuery, JSONLD, POST) 1134 ct = result.info()["content-type"] 1135 assert True in [one in ct for one in _RDF_JSONLD], ct 1136 results = result.convert() 1137 self.assertEqual(type(results), ConjunctiveGraph) 1138 1139 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1140 def testDescribeByPOSTinJSONLD_Conneg(self): 1141 result = self.__generic(describeQuery, JSONLD, POST, onlyConneg=True) 1142 ct = result.info()["content-type"] 1143 assert True in [one in ct for one in _RDF_JSONLD], ct 1144 results = result.convert() 1145 self.assertEqual(type(results), ConjunctiveGraph) 1146 1147 # Asking for an unexpected return format for DESCRIBE queryType. 1148 # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1149 def testDescribeByGETinCSV_Unexpected(self): 1150 result = self.__generic(describeQuery, CSV, GET) 1151 ct = result.info()["content-type"] 1152 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1153 results = result.convert() 1154 self.assertEqual(type(results), bytes) 1155 1156 # Asking for an unexpected return format for DESCRIBE queryType. 1157 # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1158 def testDescribeByGETinCSV_Unexpected_Conneg(self): 1159 result = self.__generic(describeQuery, CSV, GET, onlyConneg=True) 1160 ct = result.info()["content-type"] 1161 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1162 results = result.convert() 1163 self.assertEqual(type(results), bytes) 1164 1165 # Asking for an unexpected return format for DESCRIBE queryType. 1166 # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1167 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1168 def testDescribeByPOSTinCSV_Unexpected(self): 1169 result = self.__generic(describeQuery, CSV, POST) 1170 ct = result.info()["content-type"] 1171 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1172 results = result.convert() 1173 self.assertEqual(type(results), ConjunctiveGraph) 1174 1175 # Asking for an unexpected return format for DESCRIBE queryType. 1176 # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1177 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1178 def testDescribeByPOSTinCSV_Unexpected_Conneg(self): 1179 result = self.__generic(describeQuery, CSV, POST, onlyConneg=True) 1180 ct = result.info()["content-type"] 1181 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1182 results = result.convert() 1183 self.assertEqual(type(results), bytes) 1184 1185 # Asking for an unexpected return format for CONSTRUCT queryType. 1186 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1187 # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) 1188 def testDescribeByGETinJSON_Unexpected(self): 1189 result = self.__generic(describeQuery, JSON, GET) 1190 ct = result.info()["content-type"] 1191 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1192 results = result.convert() 1193 self.assertEqual(type(results), bytes) 1194 1195 # Asking for an unexpected return format for DESCRIBE queryType. 1196 # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1197 def testDescribeByGETinJSON_Unexpected_Conneg(self): 1198 result = self.__generic(describeQuery, JSON, GET, onlyConneg=True) 1199 ct = result.info()["content-type"] 1200 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1201 results = result.convert() 1202 self.assertEqual(type(results), bytes) 1203 1204 # Asking for an unexpected return format for CONSTRUCT queryType. 1205 # For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1206 # json is NOT an alias of json-ld in Fuseki (only in Fuseki2) 1207 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1208 def testDescribeByPOSTinJSON_Unexpected(self): 1209 result = self.__generic(describeQuery, JSON, POST) 1210 ct = result.info()["content-type"] 1211 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1212 results = result.convert() 1213 self.assertEqual(type(results), ConjunctiveGraph) 1214 1215 # Asking for an unexpected return format for DESCRIBE queryType. 1216 # For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle 1217 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1218 def testDescribeByPOSTinJSON_Unexpected_Conneg(self): 1219 result = self.__generic(describeQuery, JSON, POST, onlyConneg=True) 1220 ct = result.info()["content-type"] 1221 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE] 1222 results = result.convert() 1223 self.assertEqual(type(results), bytes) 1224 1225 # Asking for an unknown return format for DESCRIBE queryType (XML is sent) 1226 def testDescribeByGETinUnknow(self): 1227 result = self.__generic(describeQuery, "foo", GET) 1228 ct = result.info()["content-type"] 1229 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 1230 results = result.convert() 1231 self.assertEqual(type(results), ConjunctiveGraph) 1232 1233 # Asking for an unknown return format for DESCRIBE queryType (XML is sent) 1234 def testDescribeByGETinUnknow_Conneg(self): 1235 result = self.__generic(describeQuery, "foo", GET, onlyConneg=True) 1236 ct = result.info()["content-type"] 1237 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 1238 results = result.convert() 1239 self.assertEqual(type(results), ConjunctiveGraph) 1240 1241 # Asking for an unknown return format for DESCRIBE queryType (XML is sent) 1242 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1243 def testDescribeByPOSTinUnknow(self): 1244 result = self.__generic(describeQuery, "bar", POST) 1245 ct = result.info()["content-type"] 1246 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 1247 results = result.convert() 1248 self.assertEqual(type(results), ConjunctiveGraph) 1249 1250 # Asking for an unknown return format for DESCRIBE queryType (XML is sent) 1251 @unittest.skip('The current SPARQL endpoint returns 500 on POST requests. Maybe it is not an issue of Fuseki') 1252 def testDescribeByPOSTinUnknow_Conneg(self): 1253 result = self.__generic(describeQuery, "bar", POST, onlyConneg=True) 1254 ct = result.info()["content-type"] 1255 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 1256 results = result.convert() 1257 self.assertEqual(type(results), ConjunctiveGraph) 1258 1259################################################################################ 1260################################################################################ 1261 1262 @unittest.skip('Fuseki returns 200 instead of 400 (error code present in the returned text response)') 1263 def testQueryBadFormed(self): 1264 self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET) 1265 1266 def testQueryManyPrefixes(self): 1267 result = self.__generic(queryManyPrefixes, XML, GET) 1268 1269 def testQueryDuplicatedPrefix(self): 1270 result = self.__generic(queryDuplicatedPrefix, XML, GET) 1271 1272 def testKeepAlive(self): 1273 sparql = SPARQLWrapper(endpoint) 1274 sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10') 1275 sparql.setReturnFormat(JSON) 1276 sparql.setMethod(GET) 1277 sparql.setUseKeepAlive() 1278 1279 sparql.query() 1280 sparql.query() 1281 1282 @unittest.skip('Line 10, column 40: Illegal prefix name escape: _. See #94') 1283 @unittest.skip('Fuseki returns 200 instead of 400 (error code present in the returned text response)') 1284 def testQueryWithComma_1(self): 1285 result = self.__generic(queryWithCommaInCurie_1, XML, GET) 1286 1287 @unittest.skip('Lexical error at line 10, column 45. Encountered: ":" (58), after : "\\". See #94') 1288 @unittest.skip('Fuseki returns 200 instead of 400 (error code present in the returned text response)') 1289 def testQueryWithComma_2(self): 1290 result = self.__generic(queryWithCommaInCurie_2, XML, GET) 1291 1292 def testQueryWithComma_3(self): 1293 result = self.__generic(queryWithCommaInUri, XML, GET) 1294 1295if __name__ == "__main__": 1296 unittest.main() 1297