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