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 = "http://202.45.139.84:10035/catalogs/fao/repositories/agrovoc" 48 49prefixes = """ 50 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 51 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 52 PREFIX skos: <http://www.w3.org/2004/02/skos/core#> 53""" 54 55selectQuery = """ 56 SELECT ?label 57 WHERE { 58 <http://aims.fao.org/aos/agrovoc/c_aca7ac6d> skos:prefLabel ?label . 59 } 60""" 61 62selectQueryCSV_TSV = """ 63 SELECT ?label ?created 64 WHERE { 65 <http://aims.fao.org/aos/agrovoc/c_aca7ac6d> skos:prefLabel ?label ; 66 <http://purl.org/dc/terms/created> ?created 67 } 68""" 69askQuery = """ 70 ASK { <http://aims.fao.org/aos/agrovoc/c_aca7ac6d> a ?type } 71""" 72 73constructQuery = """ 74 CONSTRUCT { 75 _:v skos:prefLabel ?label . 76 _:v rdfs:comment "this is only a mock node to test library" 77 } 78 WHERE { 79 <http://aims.fao.org/aos/agrovoc/c_aca7ac6d> skos:prefLabel ?label . 80 } 81""" 82 83describeQuery = """ 84 DESCRIBE <http://aims.fao.org/aos/agrovoc/c_aca7ac6d> 85""" 86 87queryBadFormed = """ 88 PREFIX prop: <http://dbpedia.org/property/> 89 PREFIX res: <http://dbpedia.org/resource/> 90 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> 91 SELECT ?lat ?long 92 WHERE { 93 res:Budapest prop:latitude ?lat; 94 prop:longitude ?long. 95 } 96""" 97 98queryManyPrefixes = """ 99 PREFIX conf: <http://richard.cyganiak.de/2007/pubby/config.rdf#> 100 PREFIX meta: <http://example.org/metadata#> 101 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 102 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 103 PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> 104 PREFIX owl: <http://www.w3.org/2002/07/owl#> 105 PREFIX dc: <http://purl.org/dc/elements/1.1/> 106 PREFIX dcterms: <http://purl.org/dc/terms/> 107 PREFIX foaf: <http://xmlns.com/foaf/0.1/> 108 PREFIX skos: <http://www.w3.org/2004/02/skos/core#> 109 PREFIX geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> 110 PREFIX dbpedia: <http://dbpedia.org/resource/> 111 PREFIX o: <http://dbpedia.org/ontology/> 112 PREFIX p: <http://dbpedia.org/property/> 113 PREFIX yago: <http://dbpedia.org/class/yago/> 114 PREFIX units: <http://dbpedia.org/units/> 115 PREFIX geonames: <http://www.geonames.org/ontology#> 116 PREFIX prv: <http://purl.org/net/provenance/ns#> 117 PREFIX prvTypes: <http://purl.org/net/provenance/types#> 118 PREFIX foo: <http://purl.org/foo> 119 120 SELECT ?label 121 WHERE { 122 <http://dbpedia.org/resource/Asturias> rdfs:label ?label . 123 } 124""" 125 126queryDuplicatedPrefix = """ 127 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 128 PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 129 130 SELECT ?s ?p ?o WHERE { 131 ?s ?p ?o . 132 } LIMIT 10 133""" 134 135queryWithCommaInCurie_1 = """ 136 PREFIX dbpedia: <http://dbpedia.org/resource/> 137 SELECT ?article ?title WHERE { 138 ?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia . 139 ?article <http://xmlns.com/foaf/0.1/isPrimaryTopicOf> ?title 140 } 141""" 142 143queryWithCommaInCurie_2 = """ 144 PREFIX dbpedia: <http://dbpedia.org/resource/> 145 SELECT ?article ?title WHERE { 146 ?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia . 147 ?article <http://xmlns.com/foaf/0.1/isPrimaryTopicOf> ?title 148 } 149""" 150 151queryWithCommaInUri = """ 152 SELECT ?article ?title WHERE { 153 ?article ?relation <http://dbpedia.org/resource/Category:Victoria,_British_Columbia> . 154 ?article <http://xmlns.com/foaf/0.1/isPrimaryTopicOf> ?title 155 } 156""" 157 158class SPARQLWrapperTests(unittest.TestCase): 159 160 def __generic(self, query, returnFormat, method, onlyConneg=True): # Allegrograph uses only content negotiation (no URL parameters). 161 sparql = SPARQLWrapper(endpoint) 162 sparql.setQuery(prefixes + query) 163 sparql.setReturnFormat(returnFormat) 164 sparql.setMethod(method) 165 sparql.setOnlyConneg(onlyConneg) 166 try: 167 result = sparql.query() 168 except HTTPError: 169 # An ugly way to get the exception, but the only one that works 170 # both on Python 2.5 and Python 3. 171 e = sys.exc_info()[1] 172 if e.code == 400: 173 sys.stdout.write("400 Bad Request, probably query is not well formed") 174 elif e.code == 406: 175 sys.stdout.write("406 Not Acceptable, maybe query is not well formed") 176 else: 177 sys.stdout.write(str(e)) 178 sys.stdout.write("\n") 179 return False 180 else: 181 return result 182 183 184################################################################################ 185################################################################################ 186 187################ 188#### SELECT #### 189################ 190 191 def testSelectByGETinXML(self): 192 result = self.__generic(selectQuery, XML, GET) 193 ct = result.info()["content-type"] 194 assert True in [one in ct for one in _SPARQL_XML], ct 195 results = result.convert() 196 results.toxml() 197 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 198 self.assertEqual(results.__class__.__name__, "Document") 199 200 def testSelectByPOSTinXML(self): 201 result = self.__generic(selectQuery, XML, POST) 202 ct = result.info()["content-type"] 203 assert True in [one in ct for one in _SPARQL_XML], ct 204 results = result.convert() 205 results.toxml() 206 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 207 self.assertEqual(results.__class__.__name__, "Document") 208 209 def testSelectByGETinCSV(self): 210 result = self.__generic(selectQueryCSV_TSV, CSV, GET) 211 ct = result.info()["content-type"] 212 assert True in [one in ct for one in _CSV], ct 213 results = result.convert() 214 self.assertEqual(type(results), bytes) 215 216 def testSelectByPOSTinCSV(self): 217 result = self.__generic(selectQueryCSV_TSV, CSV, POST) 218 ct = result.info()["content-type"] 219 assert True in [one in ct for one in _CSV], ct 220 results = result.convert() 221 self.assertEqual(type(results), bytes) 222 223 def testSelectByGETinTSV(self): 224 result = self.__generic(selectQueryCSV_TSV, TSV, GET) 225 ct = result.info()["content-type"] 226 assert True in [one in ct for one in _TSV], ct 227 results = result.convert() 228 self.assertEqual(type(results), bytes) 229 230 def testSelectByPOSTinTSV(self): 231 result = self.__generic(selectQueryCSV_TSV, TSV, POST) 232 ct = result.info()["content-type"] 233 assert True in [one in ct for one in _TSV], ct 234 results = result.convert() 235 self.assertEqual(type(results), bytes) 236 237 def testSelectByGETinJSON(self): 238 result = self.__generic(selectQuery, JSON, GET) 239 ct = result.info()["content-type"] 240 assert True in [one in ct for one in _SPARQL_JSON], ct 241 results = result.convert() 242 self.assertEqual(type(results), dict) 243 244 def testSelectByPOSTinJSON(self): 245 result = self.__generic(selectQuery, JSON, POST) 246 ct = result.info()["content-type"] 247 assert True in [one in ct for one in _SPARQL_JSON], ct 248 results = result.convert() 249 self.assertEqual(type(results), dict) 250 251 # asking for an unexpected return format for SELECT queryType 252 def testSelectByGETinN3(self): 253 result = self.__generic(selectQuery, N3, GET) 254 ct = result.info()["content-type"] 255 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 256 results = result.convert() 257 results.toxml() 258 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 259 self.assertEqual(results.__class__.__name__, "Document") 260 261 # asking for an unexpected return format for SELECT queryType 262 def testSelectByPOSTinN3(self): 263 result = self.__generic(selectQuery, N3, POST) 264 ct = result.info()["content-type"] 265 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 266 results = result.convert() 267 results.toxml() 268 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 269 self.assertEqual(results.__class__.__name__, "Document") 270 271 # asking for an unexpected return format for SELECT queryType 272 def testSelectByGETinJSONLD(self): 273 result = self.__generic(selectQuery, JSONLD, GET) 274 ct = result.info()["content-type"] 275 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 276 results = result.convert() 277 results.toxml() 278 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 279 self.assertEqual(results.__class__.__name__, "Document") 280 281 # asking for an unexpected return format for SELECT queryType 282 def testSelectByPOSTinJSONLD(self): 283 result = self.__generic(selectQuery, JSONLD, POST) 284 ct = result.info()["content-type"] 285 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 286 results = result.convert() 287 results.toxml() 288 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 289 self.assertEqual(results.__class__.__name__, "Document") 290 291 # asking for an unknown return format for SELECT queryType (XML is sent) 292 def testSelectByGETinUnknow(self): 293 result = self.__generic(selectQuery, "foo", GET) 294 ct = result.info()["content-type"] 295 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 296 results = result.convert() 297 results.toxml() 298 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 299 self.assertEqual(results.__class__.__name__, "Document") 300 301 # asking for an unknown return format for SELECT queryType (XML is sent) 302 def testSelectByPOSTinUnknow(self): 303 result = self.__generic(selectQuery, "bar", POST) 304 ct = result.info()["content-type"] 305 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 306 results = result.convert() 307 results.toxml() 308 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 309 self.assertEqual(results.__class__.__name__, "Document") 310 311################################################################################ 312################################################################################ 313 314############# 315#### ASK #### 316############# 317 318 def testAskByGETinXML(self): 319 result = self.__generic(askQuery, XML, GET) 320 ct = result.info()["content-type"] 321 assert True in [one in ct for one in _SPARQL_XML], ct 322 results = result.convert() 323 results.toxml() 324 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 325 self.assertEqual(results.__class__.__name__, "Document") 326 327 def testAskByPOSTinXML(self): 328 result = self.__generic(askQuery, XML, POST) 329 ct = result.info()["content-type"] 330 assert True in [one in ct for one in _SPARQL_XML], ct 331 results = result.convert() 332 results.toxml() 333 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 334 self.assertEqual(results.__class__.__name__, "Document") 335 336 @unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type") 337 def testAskByGETinCSV(self): 338 result = self.__generic(askQuery, CSV, GET) 339 ct = result.info()["content-type"] 340 assert True in [one in ct for one in _CSV], ct 341 results = result.convert() 342 343 @unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type") 344 def testAskByPOSTinCSV(self): 345 result = self.__generic(askQuery, CSV, POST) 346 ct = result.info()["content-type"] 347 assert True in [one in ct for one in _CSV], ct 348 results = result.convert() 349 350 @unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type") 351 def testAskByGETinTSV(self): 352 result = self.__generic(askQuery, TSV, GET) 353 ct = result.info()["content-type"] 354 assert True in [one in ct for one in _TSV], ct 355 results = result.convert() 356 357 @unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type") 358 def testAskByPOSTinTSV(self): 359 result = self.__generic(askQuery, TSV, POST) 360 ct = result.info()["content-type"] 361 assert True in [one in ct for one in _TSV], ct 362 results = result.convert() 363 364 def testAskByGETinJSON(self): 365 result = self.__generic(askQuery, JSON, GET) 366 ct = result.info()["content-type"] 367 assert True in [one in ct for one in _SPARQL_JSON], ct 368 results = result.convert() 369 self.assertEqual(type(results), dict) 370 371 def testAskByPOSTinJSON(self): 372 result = self.__generic(askQuery, JSON, POST) 373 ct = result.info()["content-type"] 374 assert True in [one in ct for one in _SPARQL_JSON], ct 375 results = result.convert() 376 self.assertEqual(type(results), dict) 377 378 # asking for an unexpected return format for ASK queryType 379 def testAskByGETinN3(self): 380 result = self.__generic(askQuery, N3, GET) 381 ct = result.info()["content-type"] 382 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 383 results = result.convert() 384 results.toxml() 385 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 386 self.assertEqual(results.__class__.__name__, "Document") 387 388 # asking for an unexpected return format for ASK queryType 389 def testAskByPOSTinN3(self): 390 result = self.__generic(askQuery, N3, POST) 391 ct = result.info()["content-type"] 392 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 393 results = result.convert() 394 results.toxml() 395 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 396 self.assertEqual(results.__class__.__name__, "Document") 397 398 # asking for an unexpected return format for ASK queryType 399 def testAskByGETinJSONLD(self): 400 result = self.__generic(askQuery, JSONLD, GET) 401 ct = result.info()["content-type"] 402 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 403 results = result.convert() 404 results.toxml() 405 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 406 self.assertEqual(results.__class__.__name__, "Document") 407 408 # asking for an unexpected return format for ASK queryType 409 def testAskByPOSTinJSONLD(self): 410 result = self.__generic(askQuery, JSONLD, POST) 411 ct = result.info()["content-type"] 412 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 413 results = result.convert() 414 results.toxml() 415 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 416 self.assertEqual(results.__class__.__name__, "Document") 417 418 # asking for an unknown return format for ASK queryType (XML is sent) 419 def testAskByGETinUnknow(self): 420 result = self.__generic(askQuery, "foo", GET) 421 ct = result.info()["content-type"] 422 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 423 results = result.convert() 424 results.toxml() 425 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 426 self.assertEqual(results.__class__.__name__, "Document") 427 428 # asking for an unknown return format for ASK queryType (XML is sent) 429 def testAskByPOSTinUnknow(self): 430 result = self.__generic(askQuery, "bar", POST) 431 ct = result.info()["content-type"] 432 assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct 433 results = result.convert() 434 results.toxml() 435 self.assertEqual(results.__class__.__module__, "xml.dom.minidom") 436 self.assertEqual(results.__class__.__name__, "Document") 437 438################################################################################ 439################################################################################ 440 441################### 442#### CONSTRUCT #### 443################### 444 445 def testConstructByGETinXML(self): 446 result = self.__generic(constructQuery, XML, GET) 447 ct = result.info()["content-type"] 448 assert True in [one in ct for one in _RDF_XML], ct 449 results = result.convert() 450 self.assertEqual(type(results), ConjunctiveGraph) 451 452 def testConstructByPOSTinXML(self): 453 result = self.__generic(constructQuery, XML, POST) 454 ct = result.info()["content-type"] 455 assert True in [one in ct for one in _RDF_XML], ct 456 results = result.convert() 457 self.assertEqual(type(results), ConjunctiveGraph) 458 459 def testConstructByGETinRDFXML(self): 460 result = self.__generic(constructQuery, RDFXML, GET) 461 ct = result.info()["content-type"] 462 assert True in [one in ct for one in _RDF_XML], ct 463 results = result.convert() 464 self.assertEqual(type(results), ConjunctiveGraph) 465 466 def testConstructByPOSTinRDFXML(self): 467 result = self.__generic(constructQuery, RDFXML, POST) 468 ct = result.info()["content-type"] 469 assert True in [one in ct for one in _RDF_XML], ct 470 results = result.convert() 471 self.assertEqual(type(results), ConjunctiveGraph) 472 473 def testConstructByGETinN3(self): 474 result = self.__generic(constructQuery, N3, GET) 475 ct = result.info()["content-type"] 476 assert True in [one in ct for one in _RDF_N3], ct 477 results = result.convert() 478 self.assertEqual(type(results), bytes) 479 480 def testConstructByPOSTinN3(self): 481 result = self.__generic(constructQuery, N3, POST) 482 ct = result.info()["content-type"] 483 assert True in [one in ct for one in _RDF_N3], ct 484 results = result.convert() 485 self.assertEqual(type(results), bytes) 486 487 # JSON-LD is not supported currently for AllegroGraph 488 @unittest.skip("JSON-LD is not supported currently for AllegroGraph") 489 def testConstructByGETinJSONLD(self): 490 result = self.__generic(constructQuery, JSONLD, GET) 491 ct = result.info()["content-type"] 492 assert True in [one in ct for one in _RDF_JSONLD], ct 493 results = result.convert() 494 self.assertEqual(type(results), ConjunctiveGraph) 495 496 # JSON-LD is not supported currently for AllegroGraph 497 @unittest.skip("JSON-LD is not supported currently for AllegroGraph") 498 def testConstructByPOSTinJSONLD(self): 499 result = self.__generic(constructQuery, JSONLD, POST) 500 ct = result.info()["content-type"] 501 assert True in [one in ct for one in _RDF_JSONLD], ct 502 results = result.convert() 503 self.assertEqual(type(results), ConjunctiveGraph) 504 505 # asking for an unexpected return format for CONSTRUCT queryType 506 def testConstructByGETinJSON(self): 507 result = self.__generic(constructQuery, JSON, GET) 508 ct = result.info()["content-type"] 509 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 510 results = result.convert() 511 self.assertEqual(type(results), ConjunctiveGraph) 512 513 # asking for an unexpected return format for CONSTRUCT queryType 514 def testConstructByPOSTinJSON(self): 515 result = self.__generic(constructQuery, JSON, POST) 516 ct = result.info()["content-type"] 517 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 518 results = result.convert() 519 self.assertEqual(type(results), ConjunctiveGraph) 520 521 # asking for an unexpected return format for CONSTRUCT queryType. For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml 522 def testConstructByGETinCSV(self): 523 result = self.__generic(constructQuery, CSV, GET, onlyConneg=True) 524 ct = result.info()["content-type"] 525 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct) 526 results = result.convert() 527 self.assertEqual(type(results), ConjunctiveGraph) 528 529 # asking for an unexpected return format for CONSTRUCT queryType. For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml 530 def testConstructByPOSTinCSV(self): 531 result = self.__generic(constructQuery, CSV, POST, onlyConneg=True) 532 ct = result.info()["content-type"] 533 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct) 534 results = result.convert() 535 self.assertEqual(type(results), ConjunctiveGraph) 536 537 # asking for an unknown return format for CONSTRUCT queryType (XML is sent) 538 def testConstructByGETinUnknow(self): 539 result = self.__generic(constructQuery, "foo", GET) 540 ct = result.info()["content-type"] 541 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 542 results = result.convert() 543 self.assertEqual(type(results), ConjunctiveGraph) 544 545 # asking for an unknown return format for CONSTRUCT queryType (XML is sent) 546 def testConstructByPOSTinUnknow(self): 547 result = self.__generic(constructQuery, "bar", POST) 548 ct = result.info()["content-type"] 549 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 550 results = result.convert() 551 self.assertEqual(type(results), ConjunctiveGraph) 552 553################################################################################ 554################################################################################ 555 556################## 557#### DESCRIBE #### 558################## 559 560 def testDescribeByGETinXML(self): 561 result = self.__generic(describeQuery, XML, GET) 562 ct = result.info()["content-type"] 563 assert True in [one in ct for one in _RDF_XML], ct 564 results = result.convert() 565 self.assertEqual(type(results), ConjunctiveGraph) 566 567 def testDescribeByPOSTinXML(self): 568 result = self.__generic(describeQuery, XML, POST) 569 ct = result.info()["content-type"] 570 assert True in [one in ct for one in _RDF_XML], ct 571 results = result.convert() 572 self.assertEqual(type(results), ConjunctiveGraph) 573 574 def testDescribeByGETinRDFXML(self): 575 result = self.__generic(describeQuery, RDFXML, GET) 576 ct = result.info()["content-type"] 577 assert True in [one in ct for one in _RDF_XML], ct 578 results = result.convert() 579 self.assertEqual(type(results), ConjunctiveGraph) 580 581 def testDescribeByPOSTinRDFXML(self): 582 result = self.__generic(describeQuery, RDFXML, POST) 583 ct = result.info()["content-type"] 584 assert True in [one in ct for one in _RDF_XML], ct 585 results = result.convert() 586 self.assertEqual(type(results), ConjunctiveGraph) 587 588 def testDescribeByGETinN3(self): 589 result = self.__generic(describeQuery, N3, GET) 590 ct = result.info()["content-type"] 591 assert True in [one in ct for one in _RDF_N3], ct 592 results = result.convert() 593 self.assertEqual(type(results), bytes) 594 595 def testDescribeByPOSTinN3(self): 596 result = self.__generic(describeQuery, N3, POST) 597 ct = result.info()["content-type"] 598 assert True in [one in ct for one in _RDF_N3], ct 599 results = result.convert() 600 self.assertEqual(type(results), bytes) 601 602 # JSON-LD is not supported currently for AllegroGraph 603 @unittest.skip("JSON-LD is not supported currently for AllegroGraph") 604 def testDescribeByGETinJSONLD(self): 605 result = self.__generic(describeQuery, JSONLD, GET) 606 ct = result.info()["content-type"] 607 assert True in [one in ct for one in _RDF_JSONLD], ct 608 results = result.convert() 609 self.assertEqual(type(results), ConjunctiveGraph) 610 611 # JSON-LD is not supported currently for AllegroGraph 612 @unittest.skip("JSON-LD is not supported currently for AllegroGraph") 613 def testDescribeByPOSTinJSONLD(self): 614 result = self.__generic(describeQuery, JSONLD, POST) 615 ct = result.info()["content-type"] 616 assert True in [one in ct for one in _RDF_JSONLD], ct 617 results = result.convert() 618 self.assertEqual(type(results), ConjunctiveGraph) 619 620 # asking for an unexpected return format for DESCRIBE queryType 621 def testDescribeByGETinJSON(self): 622 result = self.__generic(describeQuery, JSON, GET) 623 ct = result.info()["content-type"] 624 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 625 results = result.convert() 626 self.assertEqual(type(results), ConjunctiveGraph) 627 628 # asking for an unexpected return format for DESCRIBE queryType 629 def testDescribeByPOSTinJSON(self): 630 result = self.__generic(describeQuery, JSON, POST) 631 ct = result.info()["content-type"] 632 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 633 results = result.convert() 634 self.assertEqual(type(results), ConjunctiveGraph) 635 636 # asking for an unexpected return format for DESCRIBE queryType. For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml 637 def testDescribeByGETinCSV(self): 638 result = self.__generic(describeQuery, CSV, GET, onlyConneg=True) 639 ct = result.info()["content-type"] 640 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct) 641 results = result.convert() 642 self.assertEqual(type(results), ConjunctiveGraph) 643 644 # asking for an unexpected return format for DESCRIBE queryType. For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml 645 def testDescribeByPOSTinCSV(self): 646 result = self.__generic(describeQuery, CSV, POST, onlyConneg=True) 647 ct = result.info()["content-type"] 648 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct) 649 results = result.convert() 650 self.assertEqual(type(results), ConjunctiveGraph) 651 652 # asking for an unknown return format for DESCRIBE queryType (XML is sent) 653 def testDescribeByGETinUnknow(self): 654 result = self.__generic(describeQuery, "foo", GET) 655 ct = result.info()["content-type"] 656 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 657 results = result.convert() 658 self.assertEqual(type(results), ConjunctiveGraph) 659 660 # asking for an unknown return format for DESCRIBE queryType (XML is sent) 661 def testDescribeByPOSTinUnknow(self): 662 result = self.__generic(describeQuery, "bar", POST) 663 ct = result.info()["content-type"] 664 assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct 665 results = result.convert() 666 self.assertEqual(type(results), ConjunctiveGraph) 667 668################################################################################ 669################################################################################ 670 671 def testQueryBadFormed(self): 672 self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET) 673 674 def testQueryManyPrefixes(self): 675 result = self.__generic(queryManyPrefixes, XML, GET) 676 677 def testQueryDuplicatedPrefix(self): 678 result = self.__generic(queryDuplicatedPrefix, XML, GET) 679 680 def testKeepAlive(self): 681 sparql = SPARQLWrapper(endpoint) 682 sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10') 683 sparql.setReturnFormat(JSON) 684 sparql.setMethod(GET) 685 sparql.setUseKeepAlive() 686 687 sparql.query() 688 sparql.query() 689 690 @unittest.skip("Allegrograph returns Value \"\\\" not recognized Error. See #94") 691 def testQueryWithComma_1(self): 692 result = self.__generic(queryWithCommaInCurie_1, XML, GET) 693 694 @unittest.skip("Allegrograph returns Value \"\\\" not recognized Error. See #94") 695 def testQueryWithComma_2(self): 696 result = self.__generic(queryWithCommaInCurie_2, XML, POST) 697 698 def testQueryWithComma_3(self): 699 result = self.__generic(queryWithCommaInUri, XML, GET) 700 701if __name__ == "__main__": 702 unittest.main() 703