diff options
| author | Sam Thursfield <sam@afuera.me.uk> | 2019-03-02 15:20:57 +0000 |
|---|---|---|
| committer | Sam Thursfield <sam@afuera.me.uk> | 2019-03-02 15:20:57 +0000 |
| commit | ea806694ab69d8e956d401ab9107330e9bc0b2e5 (patch) | |
| tree | 33d8872505b8b0d98afbad443aaa920c23d14c56 | |
| parent | 76dbeeef8f5d136f14a9f5c5d8fb495faf5e44ee (diff) | |
| parent | fda451efccf07607f4edbbc5be9329fdf7c48b97 (diff) | |
| download | tracker-ea806694ab69d8e956d401ab9107330e9bc0b2e5.tar.gz | |
Merge branch 'sam/autopep8' into 'master'
functional-tests: Reformat in line with Python standards
See merge request GNOME/tracker!67
24 files changed, 1486 insertions, 1448 deletions
diff --git a/tests/functional-tests/01-insertion.py b/tests/functional-tests/01-insertion.py index d9839fc08..d8f8e2188 100755 --- a/tests/functional-tests/01-insertion.py +++ b/tests/functional-tests/01-insertion.py @@ -30,52 +30,52 @@ import datetime import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TrackerStoreInsertionTests (CommonTrackerStoreTest): - """ - Insert single and multiple-valued properties, dates (ok and broken) - and check the results - """ + """ + Insert single and multiple-valued properties, dates (ok and broken) + and check the results + """ - def test_insert_01 (self): - """ - Simple insert of two triplets. + def test_insert_01(self): + """ + Simple insert of two triplets. - 1. Insert a InformationElement with title. - 2. TEST: Query the title of that information element - 3. Remove the InformationElement to keep everything as it was before - """ + 1. Insert a InformationElement with title. + 2. TEST: Query the title of that information element + 3. Remove the InformationElement to keep everything as it was before + """ - uri = "tracker://test_insert_01/" + str(random.randint (0, 100)) - insert = """ + uri = "tracker://test_insert_01/" + str(random.randint(0, 100)) + insert = """ INSERT { <%s> a nie:InformationElement; nie:title \"test_insert_01\". } """ % (uri) - self.tracker.update (insert) + self.tracker.update(insert) - """ verify the inserted item """ - query = """ + """ verify the inserted item """ + query = """ SELECT ?t WHERE { <%s> a nie:InformationElement ; nie:title ?t . } """ % (uri) - results = self.tracker.query (query) + results = self.tracker.query(query) - self.assertEqual (str(results[0][0]), "test_insert_01") + self.assertEqual(str(results[0][0]), "test_insert_01") - """ delete the inserted item """ - delete = """ + """ delete the inserted item """ + delete = """ DELETE { <%s> a rdfs:Resource. } """ % (uri) - self.tracker.update (delete) + self.tracker.update(delete) + def test_insert_02(self): + """ + Insert of a bigger set of triplets (linking two objects) + """ - def test_insert_02(self): - """ - Insert of a bigger set of triplets (linking two objects) - """ - - self.tracker.update(""" + self.tracker.update(""" INSERT { <urn:uuid:bob-dylan> a nmm:Artist; nmm:artistName 'Bob Dylan'. @@ -91,7 +91,7 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): } """) - QUERY = """ + QUERY = """ SELECT ?uri ?title ?length WHERE { ?uri a nmm:MusicPiece ; nmm:performer <urn:uuid:bob-dylan> ; @@ -100,27 +100,26 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): } """ - result = self.tracker.query (QUERY) - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 3) # uri, title, length - self.assertEqual (result[0][0], "file:///a/b/c/10_song3.mp3") - self.assertEqual (result[0][1], "Subterranean homesick blues") - self.assertEqual (result[0][2], "219252") + result = self.tracker.query(QUERY) + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 3) # uri, title, length + self.assertEqual(result[0][0], "file:///a/b/c/10_song3.mp3") + self.assertEqual(result[0][1], "Subterranean homesick blues") + self.assertEqual(result[0][2], "219252") - self.tracker.update (""" + self.tracker.update (""" DELETE { <urn:uuid:bob-dylan> a rdfs:Resource. <file:///a/b/c/10_song3.mp3> a rdfs:Resource. } """) + def test_insert_03(self): + """ + Checking all the values are inserted + """ - def test_insert_03(self): - """ - Checking all the values are inserted - """ - - self.tracker.update(""" + self.tracker.update(""" INSERT { <urn:uuid:7646004> a nmm:Artist; nmm:artistName 'John Lennon' . @@ -141,7 +140,7 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): """) - QUERY = """ + QUERY = """ SELECT ?artist ?length ?trackN ?album ?size ?flm ?fc ?filename WHERE { <file:///a/b/c/imagine.mp3> a nmm:MusicPiece ; nmm:performer ?x ; @@ -157,21 +156,21 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): ?y nie:title ?album. } """ - result = self.tracker.query(QUERY) - - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 8) - self.assertEqual (result[0][0], "John Lennon") - self.assertEqual (result[0][1], "219252") - self.assertEqual (result[0][2], "11") - self.assertEqual (result[0][3], "Imagine") - self.assertEqual (result[0][4], "17630") - # FIXME Tracker returns this translated to the current timezone - #self.assertEquals (result[0][5], "2008-12-23T11:47:02Z") - #self.assertEquals (result[0][6], "2008-12-16T10:41:20Z") - self.assertEqual (result[0][7], "imagine.mp3") - - self.tracker.update (""" + result = self.tracker.query(QUERY) + + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 8) + self.assertEqual(result[0][0], "John Lennon") + self.assertEqual(result[0][1], "219252") + self.assertEqual(result[0][2], "11") + self.assertEqual(result[0][3], "Imagine") + self.assertEqual(result[0][4], "17630") + # FIXME Tracker returns this translated to the current timezone + #self.assertEquals (result[0][5], "2008-12-23T11:47:02Z") + #self.assertEquals (result[0][6], "2008-12-16T10:41:20Z") + self.assertEqual(result[0][7], "imagine.mp3") + + self.tracker.update (""" DELETE { <urn:uuid:123123123> a rdfs:Resource . } @@ -181,16 +180,13 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): } """) - - - - def test_insert_04(self): - """ - Insert, delete same single valued properties multiple times. - """ - for i in range (0, 3): - # Delete single valued properties of music file. - self.tracker.update(""" + def test_insert_04(self): + """ + Insert, delete same single valued properties multiple times. + """ + for i in range(0, 3): + # Delete single valued properties of music file. + self.tracker.update(""" DELETE { <test://instance-1> nie:usageCounter ?v } WHERE { @@ -203,194 +199,196 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): } """) - # Insert the same single valued properties of music file. - self.tracker.update(""" + # Insert the same single valued properties of music file. + self.tracker.update(""" INSERT { <test://instance-1> a nmm:MusicPiece, nfo:FileDataObject; nie:usageCounter '%d'; nie:contentAccessed '2000-01-01T00:4%d:47Z' . }""" % (i, i)) - # Query for the property values and verify whether the last change is applied. - result = self.tracker.query (""" + # Query for the property values and verify whether the last change + # is applied. + result = self.tracker.query (""" SELECT ?playcount ?date WHERE { <test://instance-1> a nmm:MusicPiece ; nie:usageCounter ?playcount ; nie:contentAccessed ?date. }""") - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 2) - self.assertEqual (int (result[0][0]), i) - self.assertEqual (result[0][1], "2000-01-01T00:4%d:47Z" % (i)) + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 2) + self.assertEqual(int(result[0][0]), i) + self.assertEqual(result[0][1], "2000-01-01T00:4%d:47Z" % (i)) - self.tracker.update (""" + self.tracker.update (""" DELETE { <test://instance-1> a rdfs:Resource. } """) - - def test_insert_05(self): - """ - Insert or replace, single valued properties multiple times. - """ - for i in range (0, 3): - # Insert the same single valued properties of music file. - self.tracker.update(""" + def test_insert_05(self): + """ + Insert or replace, single valued properties multiple times. + """ + for i in range(0, 3): + # Insert the same single valued properties of music file. + self.tracker.update(""" INSERT OR REPLACE { <test://instance-1> a nmm:MusicPiece, nfo:FileDataObject; nie:usageCounter '%d'; nie:contentAccessed '2000-01-01T00:4%d:47Z' . }""" % (i, i)) - # Query for the property values and verify whether the last change is applied. - result = self.tracker.query (""" + # Query for the property values and verify whether the last change + # is applied. + result = self.tracker.query (""" SELECT ?playcount ?date WHERE { <test://instance-1> a nmm:MusicPiece ; nie:usageCounter ?playcount ; nie:contentAccessed ?date. }""") - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 2) - self.assertEqual (int (result[0][0]), i) - self.assertEqual (result[0][1], "2000-01-01T00:4%d:47Z" % (i)) + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 2) + self.assertEqual(int(result[0][0]), i) + self.assertEqual(result[0][1], "2000-01-01T00:4%d:47Z" % (i)) - self.tracker.update (""" + self.tracker.update (""" DELETE { <test://instance-1> a rdfs:Resource. } """) - def test_insert_06(self): - """ - Insert or replace, single and multi valued properties multiple times. - """ - for i in range (0, 3): - # Insert the same single valued properties and insert multi valued properties at the same time - self.tracker.update(""" + def test_insert_06(self): + """ + Insert or replace, single and multi valued properties multiple times. + """ + for i in range(0, 3): + # Insert the same single valued properties and insert multi valued + # properties at the same time + self.tracker.update(""" INSERT OR REPLACE { <test://instance-2> a nie:InformationElement; nie:title '%d'; nie:keyword '%d' }""" % (i, i)) - # Query for the property values and verify whether the last change is applied. - result = self.tracker.query (""" + # Query for the property values and verify whether the last change + # is applied. + result = self.tracker.query (""" SELECT ?t ?k WHERE { <test://instance-2> nie:title ?t ; nie:keyword ?k }""") - self.assertEqual (len (result), 3) - self.assertEqual (len (result[0]), 2) - self.assertEqual (result[0][0], "%d" % i) - self.assertEqual (result[0][1], "0") + self.assertEqual(len(result), 3) + self.assertEqual(len(result[0]), 2) + self.assertEqual(result[0][0], "%d" % i) + self.assertEqual(result[0][1], "0") - self.assertEqual (result[1][0], "%d" % i) - self.assertEqual (result[1][1], "1") + self.assertEqual(result[1][0], "%d" % i) + self.assertEqual(result[1][1], "1") - self.assertEqual (result[2][0], "%d" % i) - self.assertEqual (result[2][1], "2") + self.assertEqual(result[2][0], "%d" % i) + self.assertEqual(result[2][1], "2") - self.tracker.update (""" + self.tracker.update (""" DELETE { <test://instance-2> a rdfs:Resource. } """) - def test_insert_07(self): - """ - Insert or replace, single and multi valued properties with domain errors. - """ + def test_insert_07(self): + """ + Insert or replace, single and multi valued properties with domain errors. + """ - try: - INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-3> nie:title 'test' }""" - self.tracker.update (INSERT_SPARQL) - except: - pass + try: + INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-3> nie:title 'test' }""" + self.tracker.update(INSERT_SPARQL) + except: + pass - INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-4> a nie:DataSource }""" - self.tracker.update (INSERT_SPARQL) + INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-4> a nie:DataSource }""" + self.tracker.update(INSERT_SPARQL) - try: - INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-5> nie:rootElementOf <test://instance-4> }""" - self.tracker.update (INSERT_SPARQL) - except: - pass + try: + INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-5> nie:rootElementOf <test://instance-4> }""" + self.tracker.update(INSERT_SPARQL) + except: + pass - INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-5> a nie:InformationElement ; nie:rootElementOf <test://instance-4> }""" - self.tracker.update (INSERT_SPARQL) + INSERT_SPARQL = """INSERT OR REPLACE { <test://instance-5> a nie:InformationElement ; nie:rootElementOf <test://instance-4> }""" + self.tracker.update(INSERT_SPARQL) - self.tracker.update (""" + self.tracker.update (""" DELETE { <test://instance-4> a rdfs:Resource. } """) - self.tracker.update (""" + self.tracker.update (""" DELETE { <test://instance-5> a rdfs:Resource. } """) - def test_insert_08(self): - """ - Insert or replace, single and multi valued properties with graphs - """ + def test_insert_08(self): + """ + Insert or replace, single and multi valued properties with graphs + """ - INSERT_SPARQL = """INSERT { GRAPH <test://graph-1> { <test://instance-6> a nie:InformationElement ; nie:title 'title 1' } }""" - self.tracker.update (INSERT_SPARQL) + INSERT_SPARQL = """INSERT { GRAPH <test://graph-1> { <test://instance-6> a nie:InformationElement ; nie:title 'title 1' } }""" + self.tracker.update(INSERT_SPARQL) - INSERT_SPARQL = """INSERT { GRAPH <test://graph-2> { <test://instance-6> nie:title 'title 1' } }""" - self.tracker.update (INSERT_SPARQL) + INSERT_SPARQL = """INSERT { GRAPH <test://graph-2> { <test://instance-6> nie:title 'title 1' } }""" + self.tracker.update(INSERT_SPARQL) - result = self.tracker.query (""" + result = self.tracker.query (""" SELECT ?g ?t WHERE { GRAPH ?g { <test://instance-6> nie:title ?t } }""") - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 2) - self.assertEqual (result[0][0], "test://graph-1") # Yes, indeed - self.assertEqual (result[0][1], "title 1") + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 2) + self.assertEqual(result[0][0], "test://graph-1") # Yes, indeed + self.assertEqual(result[0][1], "title 1") - INSERT_SPARQL = """INSERT OR REPLACE { GRAPH <test://graph-2> { <test://instance-6> nie:title 'title 1' } }""" - self.tracker.update (INSERT_SPARQL) + INSERT_SPARQL = """INSERT OR REPLACE { GRAPH <test://graph-2> { <test://instance-6> nie:title 'title 1' } }""" + self.tracker.update(INSERT_SPARQL) - result = self.tracker.query (""" + result = self.tracker.query (""" SELECT ?g ?t WHERE { GRAPH ?g { <test://instance-6> nie:title ?t } }""") - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 2) - self.assertEqual (result[0][0], "test://graph-2") # Yup, that's right - self.assertEqual (result[0][1], "title 1") + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 2) + self.assertEqual(result[0][0], "test://graph-2") # Yup, that's right + self.assertEqual(result[0][1], "title 1") + INSERT_SPARQL = """INSERT OR REPLACE { GRAPH <test://graph-3> { <test://instance-6> nie:title 'title 2' } }""" + self.tracker.update(INSERT_SPARQL) - INSERT_SPARQL = """INSERT OR REPLACE { GRAPH <test://graph-3> { <test://instance-6> nie:title 'title 2' } }""" - self.tracker.update (INSERT_SPARQL) - - result = self.tracker.query (""" + result = self.tracker.query (""" SELECT ?g ?t WHERE { GRAPH ?g { <test://instance-6> nie:title ?t } }""") - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 2) - self.assertEqual (result[0][0], "test://graph-3") - self.assertEqual (result[0][1], "title 2") + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 2) + self.assertEqual(result[0][0], "test://graph-3") + self.assertEqual(result[0][1], "title 2") - self.tracker.update (""" + self.tracker.update (""" DELETE { <test://instance-6> a rdfs:Resource. } """) - def __insert_valid_date_test (self, datestring, year, month, day, hours, minutes, seconds, timezone): - """ - Insert a property with datestring value, retrieve its components and validate against - the expected results (all the other parameters) - """ - testId = random.randint (10, 1000) - self.tracker.update (""" + def __insert_valid_date_test(self, datestring, year, month, day, hours, minutes, seconds, timezone): + """ + Insert a property with datestring value, retrieve its components and validate against + the expected results (all the other parameters) + """ + testId = random.randint(10, 1000) + self.tracker.update (""" INSERT { <test://instance-insert-date-%d> a nie:InformationElement; nie:informationElementDate '%s'. } """ % (testId, datestring)) - result = self.tracker.query (""" + result = self.tracker.query (""" SELECT fn:year-from-dateTime (?v) fn:month-from-dateTime (?v) fn:day-from-dateTime (?v) @@ -403,80 +401,76 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): nie:informationElementDate ?v . } """ % (testId)) - try: - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 7) - self.assertEqual (result[0][0], year) - self.assertEqual (result[0][1], month) - self.assertEqual (result[0][2], day) - self.assertEqual (result[0][3], hours) - self.assertEqual (result[0][4], minutes) - self.assertEqual (result[0][5], seconds) - # FIXME To validate this we need to take into account the locale - # self.assertEquals (result[0][7], timezone) - finally: - self.tracker.update (""" + try: + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 7) + self.assertEqual(result[0][0], year) + self.assertEqual(result[0][1], month) + self.assertEqual(result[0][2], day) + self.assertEqual(result[0][3], hours) + self.assertEqual(result[0][4], minutes) + self.assertEqual(result[0][5], seconds) + # FIXME To validate this we need to take into account the locale + # self.assertEquals (result[0][7], timezone) + finally: + self.tracker.update (""" DELETE { <test://instance-insert-date-%d> a rdfs:Resource. } """ % (testId)) + """Date-Time storage testing """ - """Date-Time storage testing """ - def test_insert_date_01 (self): - """ - 1. Insert a InformationElement with date having local timezone info. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_valid_date_test ("2004-05-06T13:14:15+0400", - "2004", "05", "06", "13", "14", "15", "14400") - - - def test_insert_date_02 (self): - """ - 1. Insert a InformationElement with date ending with "Z" in TZD. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_valid_date_test ("2004-05-06T13:14:15Z", - "2004", "05", "06", "13", "14", "15", "0") - - def test_insert_date_03 (self): - """ - 1. Insert a InformationElement with date ending with no TZD. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_valid_date_test ("2004-05-06T13:14:15", - "2004", "05", "06", "13", "14", "15", "10800") # HEL timezone? - - - #@ut.skipIf (1, "It times out in the daemon. Investigate") - def test_insert_date_04 (self): - """ - 1. Insert a InformationElement with date having local timezone info - with some minutes in it. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_valid_date_test ("2004-05-06T13:14:15+0230", - "2004", "05", "06", "13", "14", "15", "9000") + def test_insert_date_01(self): + """ + 1. Insert a InformationElement with date having local timezone info. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_valid_date_test("2004-05-06T13:14:15+0400", + "2004", "05", "06", "13", "14", "15", "14400") + def test_insert_date_02(self): + """ + 1. Insert a InformationElement with date ending with "Z" in TZD. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_valid_date_test("2004-05-06T13:14:15Z", + "2004", "05", "06", "13", "14", "15", "0") - #@ut.skipIf (1, "It times out in the daemon. Investigate") - def __test_insert_date_05 (self): - """ - 1. Insert a InformationElement with date having local timezone info in negative. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_valid_date_test ("2004-05-06T13:14:15-0230", - "2004", "05", "06", "13", "14", "15", "-9000") + def test_insert_date_03(self): + """ + 1. Insert a InformationElement with date ending with no TZD. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_valid_date_test("2004-05-06T13:14:15", + "2004", "05", "06", "13", "14", "15", "10800") # HEL timezone? + #@ut.skipIf (1, "It times out in the daemon. Investigate") + def test_insert_date_04(self): + """ + 1. Insert a InformationElement with date having local timezone info + with some minutes in it. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_valid_date_test("2004-05-06T13:14:15+0230", + "2004", "05", "06", "13", "14", "15", "9000") - def __insert_invalid_date_test (self, datestring): - self.assertRaises (Exception, self.tracker.update, """ + #@ut.skipIf (1, "It times out in the daemon. Investigate") + def __test_insert_date_05(self): + """ + 1. Insert a InformationElement with date having local timezone info in negative. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_valid_date_test("2004-05-06T13:14:15-0230", + "2004", "05", "06", "13", "14", "15", "-9000") + + def __insert_invalid_date_test(self, datestring): + self.assertRaises (Exception, self.tracker.update, """ INSERT { <test://instance-insert-invalid-date-01> a nie:InformationElement; nie:informationElementDate '204-05-06T13:14:15+0400'. } """) - result = self.tracker.query (""" + result = self.tracker.query (""" SELECT fn:year-from-dateTime (?v) fn:month-from-dateTime (?v) fn:day-from-dateTime (?v) @@ -489,145 +483,162 @@ class TrackerStoreInsertionTests (CommonTrackerStoreTest): nie:informationElementDate ?v . } """) - self.assertEqual (len (result), 0) - - #@ut.skipIf (1, "It times out in the daemon. Investigate") - def test_insert_invalid_date_01 (self): - """ - 1. Insert a InformationElement with invalid year in date. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_invalid_date_test ("204-05-06T13:14:15+0400") - - - #@ut.skipIf (1, "It times out in the daemon. Investigate") - def test_insert_invalid_date_02 (self): - """ - 1. Insert a InformationElement with date without time. - 2. TEST: Query and verify the various componentes of date - """ - self.__insert_invalid_date_test ("2004-05-06") + self.assertEqual(len(result), 0) + #@ut.skipIf (1, "It times out in the daemon. Investigate") + def test_insert_invalid_date_01(self): + """ + 1. Insert a InformationElement with invalid year in date. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_invalid_date_test("204-05-06T13:14:15+0400") + #@ut.skipIf (1, "It times out in the daemon. Investigate") + def test_insert_invalid_date_02(self): + """ + 1. Insert a InformationElement with date without time. + 2. TEST: Query and verify the various componentes of date + """ + self.__insert_invalid_date_test("2004-05-06") - #@ut.skipIf (1, "It times out in the daemon. Investigate") - def test_insert_invalid_date_03 (self): - """ - 1. Insert a InformationElement with date without time but only the "T" separator. - """ - self.__insert_invalid_date_test ("2004-05-06T") + #@ut.skipIf (1, "It times out in the daemon. Investigate") + def test_insert_invalid_date_03(self): + """ + 1. Insert a InformationElement with date without time but only the "T" separator. + """ + self.__insert_invalid_date_test("2004-05-06T") - #@ut.skipIf (1, "It times out in the daemon. Investigate") - def test_insert_invalid_date_04 (self): - """ - 1. Insert a InformationElement with date without time but only the "T" separator. - """ - self.__insert_invalid_date_test ("2004-05-06T1g:14:15-0200") + #@ut.skipIf (1, "It times out in the daemon. Investigate") + def test_insert_invalid_date_04(self): + """ + 1. Insert a InformationElement with date without time but only the "T" separator. + """ + self.__insert_invalid_date_test("2004-05-06T1g:14:15-0200") - def test_insert_duplicated_url_01 (self): - """ - 1. Insert a FileDataObject with a known nie:url, twice - """ + def test_insert_duplicated_url_01(self): + """ + 1. Insert a FileDataObject with a known nie:url, twice + """ - url = "file:///some/magic/path/here" + url = "file:///some/magic/path/here" - insert = """ + insert = """ INSERT { _:tag a nfo:FileDataObject; nie:url '%s'. } """ % (url) - # First insert should go ok - self.tracker.update (insert) - # Second insert should not be ok - try: - self.tracker.update (insert) - except Exception: - pass + # First insert should go ok + self.tracker.update(insert) + # Second insert should not be ok + try: + self.tracker.update(insert) + except Exception: + pass - # Only 1 element must be available with the given nie:url - select = """ + # Only 1 element must be available with the given nie:url + select = """ SELECT ?u WHERE { ?u nie:url \"%s\" } """ % (url) - self.assertEqual (len (self.tracker.query (select)), 1) + self.assertEqual(len(self.tracker.query(select)), 1) - # Cleanup - self.tracker.update (""" + # Cleanup + self.tracker.update (""" DELETE { ?u a rdfs:Resource } WHERE { ?u a rdfs:Resource ; nie:url '%s' } """ % (url)) + def test_insert_replace_null(self): + """ + Insert or replace, with null + """ - def test_insert_replace_null(self): - """ - Insert or replace, with null - """ + self.tracker.update( + """INSERT { <test://instance-null> a nie:DataObject, nie:InformationElement }""") + self.tracker.update( + """INSERT { <test://instance-ds1> a nie:DataSource }""") + self.tracker.update( + """INSERT { <test://instance-ds2> a nie:DataSource }""") + self.tracker.update( + """INSERT { <test://instance-ds3> a nie:DataSource }""") + self.tracker.update( + """INSERT { <test://instance-null> nie:dataSource <test://instance-ds1>, <test://instance-ds2>, <test://instance-ds3> }""") + + # null upfront, reset of list, rewrite of new list + self.tracker.update( + """INSERT OR REPLACE { <test://instance-null> nie:dataSource null, <test://instance-ds1>, <test://instance-ds2> }""") + result = self.tracker.query( + """SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") + self.assertEqual(len(result), 2) + self.assertEqual(len(result[0]), 1) + self.assertEqual(len(result[1]), 1) + self.assertEqual(result[0][0], "test://instance-ds1") + self.assertEqual(result[1][0], "test://instance-ds2") + + # null upfront, reset of list, rewrite of new list, second test + self.tracker.update( + """INSERT OR REPLACE { <test://instance-null> nie:dataSource null, <test://instance-ds1>, <test://instance-ds2>, <test://instance-ds3> }""") + result = self.tracker.query( + """SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") + self.assertEqual(len(result), 3) + self.assertEqual(len(result[0]), 1) + self.assertEqual(len(result[1]), 1) + self.assertEqual(len(result[2]), 1) + self.assertEqual(result[0][0], "test://instance-ds1") + self.assertEqual(result[1][0], "test://instance-ds2") + self.assertEqual(result[2][0], "test://instance-ds3") + + # null in the middle, rewrite of new list + self.tracker.update( + """INSERT OR REPLACE { <test://instance-null> nie:dataSource <test://instance-ds1>, null, <test://instance-ds2>, <test://instance-ds3> }""") + result = self.tracker.query( + """SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") + self.assertEqual(len(result), 2) + self.assertEqual(len(result[0]), 1) + self.assertEqual(len(result[1]), 1) + self.assertEqual(result[0][0], "test://instance-ds2") + self.assertEqual(result[1][0], "test://instance-ds3") + + # null at the end + self.tracker.update( + """INSERT OR REPLACE { <test://instance-null> nie:dataSource <test://instance-ds1>, <test://instance-ds2>, <test://instance-ds3>, null }""") + result = self.tracker.query( + """SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") + self.assertEqual(len(result), 0) + + # Multiple nulls + self.tracker.update( + """INSERT OR REPLACE { <test://instance-null> nie:dataSource null, <test://instance-ds1>, null, <test://instance-ds2>, <test://instance-ds3> }""") + result = self.tracker.query( + """SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") + self.assertEqual(len(result), 2) + self.assertEqual(len(result[0]), 1) + self.assertEqual(len(result[1]), 1) + self.assertEqual(result[0][0], "test://instance-ds2") + self.assertEqual(result[1][0], "test://instance-ds3") + + self.tracker.update( + """DELETE { <test://instance-null> a rdfs:Resource. }""") + self.tracker.update( + """DELETE { <test://instance-ds1> a rdfs:Resource. }""") + self.tracker.update( + """DELETE { <test://instance-ds2> a rdfs:Resource. }""") + self.tracker.update( + """DELETE { <test://instance-ds3> a rdfs:Resource. }""") - self.tracker.update("""INSERT { <test://instance-null> a nie:DataObject, nie:InformationElement }""") - self.tracker.update("""INSERT { <test://instance-ds1> a nie:DataSource }""") - self.tracker.update("""INSERT { <test://instance-ds2> a nie:DataSource }""") - self.tracker.update("""INSERT { <test://instance-ds3> a nie:DataSource }""") - self.tracker.update("""INSERT { <test://instance-null> nie:dataSource <test://instance-ds1>, <test://instance-ds2>, <test://instance-ds3> }""") - - # null upfront, reset of list, rewrite of new list - self.tracker.update("""INSERT OR REPLACE { <test://instance-null> nie:dataSource null, <test://instance-ds1>, <test://instance-ds2> }""") - result = self.tracker.query ("""SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") - self.assertEqual (len (result), 2) - self.assertEqual (len (result[0]), 1) - self.assertEqual (len (result[1]), 1) - self.assertEqual (result[0][0], "test://instance-ds1") - self.assertEqual (result[1][0], "test://instance-ds2") - - # null upfront, reset of list, rewrite of new list, second test - self.tracker.update("""INSERT OR REPLACE { <test://instance-null> nie:dataSource null, <test://instance-ds1>, <test://instance-ds2>, <test://instance-ds3> }""") - result = self.tracker.query ("""SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") - self.assertEqual (len (result), 3) - self.assertEqual (len (result[0]), 1) - self.assertEqual (len (result[1]), 1) - self.assertEqual (len (result[2]), 1) - self.assertEqual (result[0][0], "test://instance-ds1") - self.assertEqual (result[1][0], "test://instance-ds2") - self.assertEqual (result[2][0], "test://instance-ds3") - - # null in the middle, rewrite of new list - self.tracker.update("""INSERT OR REPLACE { <test://instance-null> nie:dataSource <test://instance-ds1>, null, <test://instance-ds2>, <test://instance-ds3> }""") - result = self.tracker.query ("""SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") - self.assertEqual (len (result), 2) - self.assertEqual (len (result[0]), 1) - self.assertEqual (len (result[1]), 1) - self.assertEqual (result[0][0], "test://instance-ds2") - self.assertEqual (result[1][0], "test://instance-ds3") - - # null at the end - self.tracker.update("""INSERT OR REPLACE { <test://instance-null> nie:dataSource <test://instance-ds1>, <test://instance-ds2>, <test://instance-ds3>, null }""") - result = self.tracker.query ("""SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") - self.assertEqual (len (result), 0) - - # Multiple nulls - self.tracker.update("""INSERT OR REPLACE { <test://instance-null> nie:dataSource null, <test://instance-ds1>, null, <test://instance-ds2>, <test://instance-ds3> }""") - result = self.tracker.query ("""SELECT ?ds WHERE { <test://instance-null> nie:dataSource ?ds }""") - self.assertEqual (len (result), 2) - self.assertEqual (len (result[0]), 1) - self.assertEqual (len (result[1]), 1) - self.assertEqual (result[0][0], "test://instance-ds2") - self.assertEqual (result[1][0], "test://instance-ds3") - - self.tracker.update ("""DELETE { <test://instance-null> a rdfs:Resource. }""") - self.tracker.update ("""DELETE { <test://instance-ds1> a rdfs:Resource. }""") - self.tracker.update ("""DELETE { <test://instance-ds2> a rdfs:Resource. }""") - self.tracker.update ("""DELETE { <test://instance-ds3> a rdfs:Resource. }""") class TrackerStoreDeleteTests (CommonTrackerStoreTest): + """ + Use DELETE in Sparql and check the information is actually removed + """ + + def test_delete_01(self): """ - Use DELETE in Sparql and check the information is actually removed + Insert triples and Delete a triple. Verify the deletion with a query """ - def test_delete_01 (self): - """ - Insert triples and Delete a triple. Verify the deletion with a query - """ - # first insert - self.tracker.update (""" + # first insert + self.tracker.update (""" INSERT { <urn:uuid:7646001> a nco:Contact; nco:fullname 'Artist_1_delete'. @@ -639,88 +650,87 @@ class TrackerStoreDeleteTests (CommonTrackerStoreTest): } """) - # verify the insertion - result = self.tracker.query (""" + # verify the insertion + result = self.tracker.query (""" SELECT ?u WHERE { ?u a nmm:MusicPiece ; nfo:genre 'Classic delete' . } """) - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 1) - self.assertEqual (result[0][0], "test://instance-test-delete-01") + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 1) + self.assertEqual(result[0][0], "test://instance-test-delete-01") - # now delete - self.tracker.update(""" + # now delete + self.tracker.update(""" DELETE { <test://instance-test-delete-01> a rdfs:Resource. } """) - # Check the instance is not there - result = self.tracker.query (""" + # Check the instance is not there + result = self.tracker.query (""" SELECT ?u WHERE { ?u a nmm:MusicPiece ; nfo:genre 'Classic delete' . } """) - self.assertEqual (len (result), 0) - + self.assertEqual(len(result), 0) - def test_delete_02 (self): - """ - Delete a MusicAlbum and count the album + def test_delete_02(self): + """ + Delete a MusicAlbum and count the album - 1. add a music album. - 2. count the number of albums - 3. delete an album - 2. count the number of albums - """ + 1. add a music album. + 2. count the number of albums + 3. delete an album + 2. count the number of albums + """ - initial = self.tracker.count_instances ("nmm:MusicAlbum") + initial = self.tracker.count_instances("nmm:MusicAlbum") - """Add a music album """ - self.tracker.update (""" + """Add a music album """ + self.tracker.update (""" INSERT { <test://instance-delete-02> a nmm:MusicAlbum; nie:title '06_Album_delete'. } """) - after_insert = self.tracker.count_instances ("nmm:MusicAlbum") - self.assertEqual (initial+1, after_insert) + after_insert = self.tracker.count_instances("nmm:MusicAlbum") + self.assertEqual(initial + 1, after_insert) - """Delete the added music album """ - self.tracker.update(""" + """Delete the added music album """ + self.tracker.update(""" DELETE { <test://instance-delete-02> a nmm:MusicAlbum. } """) - """get the count of music albums""" - after_removal = self.tracker.count_instances ("nmm:MusicAlbum") + """get the count of music albums""" + after_removal = self.tracker.count_instances("nmm:MusicAlbum") - self.assertEqual (after_removal, initial) + self.assertEqual(after_removal, initial) class TrackerStoreBatchUpdateTest (CommonTrackerStoreTest): + """ + Insert data using the BatchSparqlUpdate method in the store + """ + + def test_batch_insert_01(self): """ - Insert data using the BatchSparqlUpdate method in the store + batch insertion of 100 contacts: + 1. insert 100 contacts. + 2. delete the inserted contacts. """ + NUMBER_OF_TEST_CONTACTS = 3 - def test_batch_insert_01(self): - """ - batch insertion of 100 contacts: - 1. insert 100 contacts. - 2. delete the inserted contacts. - """ - NUMBER_OF_TEST_CONTACTS = 3 - - # query no. of existing contacts. (predefined instances in the DB) - count_before_insert = self.tracker.count_instances ("nco:PersonContact") + # query no. of existing contacts. (predefined instances in the DB) + count_before_insert = self.tracker.count_instances("nco:PersonContact") - # insert contacts. - CONTACT_TEMPLATE = """ + # insert contacts. + CONTACT_TEMPLATE = """ <test://instance-contact-%d> a nco:PersonContact ; nco:nameGiven 'Contact-name %d'; nco:nameFamily 'Contact-family %d'; @@ -729,33 +739,37 @@ class TrackerStoreBatchUpdateTest (CommonTrackerStoreTest): nco:hasPhoneNumber <tel:%s> . """ - global contact_list - contact_list = [] - def complete_contact (contact_template): - random_phone = "".join ([str(random.randint (0, 9)) for i in range (0, 9)]) - contact_counter = random.randint (0, 10000) - - # Avoid duplicates - while contact_counter in contact_list: - contact_counter = random.randint (0, 10000) - contact_list.append (contact_counter) - - return contact_template % (contact_counter, - contact_counter, - contact_counter, - contact_counter, - random_phone) - - contacts = list(map (complete_contact, [CONTACT_TEMPLATE] * NUMBER_OF_TEST_CONTACTS)) - INSERT_SPARQL = "\n".join (["INSERT {"] + contacts +["}"]) - self.tracker.batch_update (INSERT_SPARQL) - - # Check all instances are in - count_after_insert = self.tracker.count_instances ("nco:PersonContact") - self.assertEqual (count_before_insert + NUMBER_OF_TEST_CONTACTS, count_after_insert) - - """ Delete the inserted contacts """ - DELETE_SPARQL = """ + global contact_list + contact_list = [] + + def complete_contact(contact_template): + random_phone = "".join([str(random.randint(0, 9)) + for i in range(0, 9)]) + contact_counter = random.randint(0, 10000) + + # Avoid duplicates + while contact_counter in contact_list: + contact_counter = random.randint(0, 10000) + contact_list.append(contact_counter) + + return contact_template % (contact_counter, + contact_counter, + contact_counter, + contact_counter, + random_phone) + + contacts = list( + map(complete_contact, [CONTACT_TEMPLATE] * NUMBER_OF_TEST_CONTACTS)) + INSERT_SPARQL = "\n".join(["INSERT {"] + contacts + ["}"]) + self.tracker.batch_update(INSERT_SPARQL) + + # Check all instances are in + count_after_insert = self.tracker.count_instances("nco:PersonContact") + self.assertEqual(count_before_insert + + NUMBER_OF_TEST_CONTACTS, count_after_insert) + + """ Delete the inserted contacts """ + DELETE_SPARQL = """ DELETE { ?x a rdfs:Resource . } WHERE { @@ -763,34 +777,35 @@ class TrackerStoreBatchUpdateTest (CommonTrackerStoreTest): nie:generator 'test-instance-to-remove' . } """ - self.tracker.update (DELETE_SPARQL) - count_final = self.tracker.count_instances ("nco:PersonContact") - self.assertEqual (count_before_insert, count_final) + self.tracker.update(DELETE_SPARQL) + count_final = self.tracker.count_instances("nco:PersonContact") + self.assertEqual(count_before_insert, count_final) + class TrackerStorePhoneNumberTest (CommonTrackerStoreTest): + """ + Tests around phone numbers (maemo specific). Inserting correct/incorrect ones + and running query to get the contact from the number. + """ + + def test_phone_01(self): """ - Tests around phone numbers (maemo specific). Inserting correct/incorrect ones - and running query to get the contact from the number. + 1. Setting the maemo:localPhoneNumber property to last 7 digits of phone number. + 2. Receiving a message from a contact whose localPhoneNumber is saved. + 3. Query messages from the local phone number """ - - def test_phone_01 (self): - """ - 1. Setting the maemo:localPhoneNumber property to last 7 digits of phone number. - 2. Receiving a message from a contact whose localPhoneNumber is saved. - 3. Query messages from the local phone number - """ - PhoneNumber = str(random.randint (0, sys.maxsize)) - UUID = str(time.time()) - UUID1 = str(random.randint (0, sys.maxsize)) - UUID2 = str(random.randint (0, sys.maxsize)) - localNumber = PhoneNumber[-7:] - d=datetime.datetime.now() - Received=d.isoformat() - ID = int(time.time())%1000 - Given_Name = 'test_GN_' + repr(ID) - Family_Name = 'test_FN_' + repr(ID) - - INSERT_CONTACT_PHONE = """ + PhoneNumber = str(random.randint(0, sys.maxsize)) + UUID = str(time.time()) + UUID1 = str(random.randint(0, sys.maxsize)) + UUID2 = str(random.randint(0, sys.maxsize)) + localNumber = PhoneNumber[-7:] + d = datetime.datetime.now() + Received = d.isoformat() + ID = int(time.time()) % 1000 + Given_Name = 'test_GN_' + repr(ID) + Family_Name = 'test_FN_' + repr(ID) + + INSERT_CONTACT_PHONE = """ INSERT { <tel:123456789> a nco:PhoneNumber ; nco:phoneNumber '00358555444333' ; @@ -803,9 +818,9 @@ class TrackerStorePhoneNumberTest (CommonTrackerStoreTest): <test://test_phone_1/contact> nco:hasPhoneNumber <tel:123456789>. } """ - self.tracker.update (INSERT_CONTACT_PHONE) + self.tracker.update(INSERT_CONTACT_PHONE) - INSERT_MESSAGE = """ + INSERT_MESSAGE = """ INSERT { <test://test_phone_1/message> a nmo:Message ; nmo:from [a nco:Contact ; nco:hasPhoneNumber <tel:123456789>]; @@ -813,26 +828,25 @@ class TrackerStorePhoneNumberTest (CommonTrackerStoreTest): nie:plainTextContent 'hello' } """ - self.tracker.update (INSERT_MESSAGE) + self.tracker.update(INSERT_MESSAGE) - QUERY_SPARQL = """ + QUERY_SPARQL = """ SELECT ?msg WHERE { ?msg a nmo:Message; nmo:from ?c . ?c nco:hasPhoneNumber ?n . ?n maemo:localPhoneNumber '5444333'. } """ - result = self.tracker.query (QUERY_SPARQL) - self.assertEqual (len (result), 1) - self.assertEqual (len (result[0]), 1) - self.assertEqual (result[0][0], "test://test_phone_1/message") - + result = self.tracker.query(QUERY_SPARQL) + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 1) + self.assertEqual(result[0][0], "test://test_phone_1/message") - def test_phone_02 (self): - """ - Inserting a local phone number which have spaces - """ - INSERT_SPARQL = """ + def test_phone_02(self): + """ + Inserting a local phone number which have spaces + """ + INSERT_SPARQL = """ INSERT { <tel+3333333333> a nco:PhoneNumber ; nco:phoneNumber <tel+3333333333> ; @@ -844,8 +858,8 @@ class TrackerStorePhoneNumberTest (CommonTrackerStoreTest): nco:hasPhoneNumber <tel+3333333333> . } """ - self.assertRaises (Exception, self.tracker.update (INSERT_SPARQL)) + self.assertRaises(Exception, self.tracker.update(INSERT_SPARQL)) if __name__ == "__main__": - ut.main() + ut.main() diff --git a/tests/functional-tests/02-sparql-bugs.py b/tests/functional-tests/02-sparql-bugs.py index 30ec777be..c5f23674f 100755 --- a/tests/functional-tests/02-sparql-bugs.py +++ b/tests/functional-tests/02-sparql-bugs.py @@ -29,11 +29,11 @@ from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreT class TrackerStoreSparqlBugsTests (CommonTrackerStoreTest): - def test_01_NB217566_union_exists_filter (self): - """ - NB217566: Use of UNION in EXISTS in a FILTER breaks filtering - """ - content = """ + def test_01_NB217566_union_exists_filter(self): + """ + NB217566: Use of UNION in EXISTS in a FILTER breaks filtering + """ + content = """ INSERT { <contact:affiliation> a nco:Affiliation ; nco:hasPhoneNumber @@ -42,10 +42,10 @@ class TrackerStoreSparqlBugsTests (CommonTrackerStoreTest): nco:hasAffiliation <contact:affiliation> . } """ - self.tracker.update (content) + self.tracker.update(content) - """ Check that these 3 queries return the same results """ - query1 = """ + """ Check that these 3 queries return the same results """ + query1 = """ SELECT ?_contact ?n WHERE { ?_contact a nco:PersonContact . { @@ -72,7 +72,7 @@ class TrackerStoreSparqlBugsTests (CommonTrackerStoreTest): } """ - query2 = """ + query2 = """ SELECT ?_contact ?n WHERE { ?_contact a nco:PersonContact . { @@ -87,7 +87,7 @@ class TrackerStoreSparqlBugsTests (CommonTrackerStoreTest): } """ - query3 = """ + query3 = """ SELECT ?_contact ?n WHERE { ?_contact a nco:PersonContact . { @@ -109,142 +109,137 @@ class TrackerStoreSparqlBugsTests (CommonTrackerStoreTest): } """ - results1 = self.tracker.query (query1) - print("1", results1) - self.assertEqual (len (results1), 1) - self.assertEqual (len (results1[0]), 2) - self.assertEqual (results1[0][0], "contact:test") - self.assertEqual (results1[0][1], "98653") - - results2 = self.tracker.query (query2) - print("2", results2) - self.assertEqual (len (results2), 1) - self.assertEqual (len (results2[0]), 2) - self.assertEqual (results2[0][0], "contact:test") - self.assertEqual (results2[0][1], "98653") - - - results3 = self.tracker.query (query3) - print("3", results3) - self.assertEqual (len (results3), 1) - self.assertEqual (len (results3[0]), 2) - self.assertEqual (results3[0][0], "contact:test") - self.assertEqual (results3[0][1], "98653") - - """ Clean the DB """ - delete = """ + results1 = self.tracker.query(query1) + print("1", results1) + self.assertEqual(len(results1), 1) + self.assertEqual(len(results1[0]), 2) + self.assertEqual(results1[0][0], "contact:test") + self.assertEqual(results1[0][1], "98653") + + results2 = self.tracker.query(query2) + print("2", results2) + self.assertEqual(len(results2), 1) + self.assertEqual(len(results2[0]), 2) + self.assertEqual(results2[0][0], "contact:test") + self.assertEqual(results2[0][1], "98653") + + results3 = self.tracker.query(query3) + print("3", results3) + self.assertEqual(len(results3), 1) + self.assertEqual(len(results3[0]), 2) + self.assertEqual(results3[0][0], "contact:test") + self.assertEqual(results3[0][1], "98653") + + """ Clean the DB """ + delete = """ DELETE { <contact:affiliation> a rdfs:Resource . <contact:test> a rdfs:Resource . } - """ - - def test_02_NB217636_delete_statements (self): - """ - Bug 217636 - Not able to delete contact using - DELETE {<contact:556> ?p ?v} WHERE {<contact:556> ?p ?v}. """ - data = """ INSERT { + + def test_02_NB217636_delete_statements(self): + """ + Bug 217636 - Not able to delete contact using + DELETE {<contact:556> ?p ?v} WHERE {<contact:556> ?p ?v}. + """ + data = """ INSERT { <contact:test-nb217636> a nco:PersonContact ; nco:fullname 'Testing bug 217636' } """ - self.tracker.update (data) + self.tracker.update(data) - results = self.tracker.query (""" + results = self.tracker.query (""" SELECT ?u WHERE { ?u a nco:PersonContact ; nco:fullname 'Testing bug 217636' . } """) - self.assertEqual (len (results), 1) - self.assertEqual (len (results[0]), 1) - self.assertEqual (results[0][0], "contact:test-nb217636") + self.assertEqual(len(results), 1) + self.assertEqual(len(results[0]), 1) + self.assertEqual(results[0][0], "contact:test-nb217636") - problematic_delete = """ + problematic_delete = """ DELETE { <contact:test-nb217636> ?p ?v } WHERE { <contact:test-nb217636> ?p ?v } """ - self.tracker.update (problematic_delete) + self.tracker.update(problematic_delete) - results_after = self.tracker.query (""" + results_after = self.tracker.query (""" SELECT ?u WHERE { ?u a nco:PersonContact ; nco:fullname 'Testing bug 217636' . } """) - self.assertEqual (len (results_after), 0) + self.assertEqual(len(results_after), 0) - # Safe deletion - delete = """ + # Safe deletion + delete = """ DELETE { <contact:test-nb217636> a rdfs:Resource. } """ - self.tracker.update (delete) - - - def test_03_NB222645_non_existing_class_resource (self): - """ - NB222645 - Inserting a resource using an non-existing class, doesn't rollback completely - """ - query = "SELECT tracker:modified (?u) ?u WHERE { ?u a nco:Contact }" - original_data = self.tracker.query (query) - - wrong_insert = "INSERT { <test://nb222645-wrong-class-contact> a nco:IMContact. } " - self.assertRaises (GLib.Error, - self.tracker.update, - wrong_insert) - - new_data = self.tracker.query (query) - self.assertEqual (len (original_data), len (new_data)) - # We could be more picky, but checking there are the same number of results - # is enough to verify the problem described in the bug. - - - def test_04_NB224760_too_long_filter (self): - """ - NB#224760 - 'too many sql variables' when filter ?sth in (long list) - """ - query = "SELECT tracker:id (?m) ?m WHERE { ?m a rdfs:Resource. FILTER (tracker:id (?m) in (%s)) }" - numbers = ",".join ([str (i) for i in range (1000, 2000)]) - - results = self.tracker.query (query % (numbers)) - - # The query will raise an exception is the bug is there - # If we are here, everything is fine. - self.assertIsNotNone (results) - - def test_05_NB281201_insert_replace_and_superproperties (self): - """ - Bug 281201 - INSERT OR REPLACE does not delete previous values for superproperties - """ - content = """INSERT { <test:resource:nb281201> a nie:InformationElement; + self.tracker.update(delete) + + def test_03_NB222645_non_existing_class_resource(self): + """ + NB222645 - Inserting a resource using an non-existing class, doesn't rollback completely + """ + query = "SELECT tracker:modified (?u) ?u WHERE { ?u a nco:Contact }" + original_data = self.tracker.query(query) + + wrong_insert = "INSERT { <test://nb222645-wrong-class-contact> a nco:IMContact. } " + self.assertRaises(GLib.Error, + self.tracker.update, + wrong_insert) + + new_data = self.tracker.query(query) + self.assertEqual(len(original_data), len(new_data)) + # We could be more picky, but checking there are the same number of results + # is enough to verify the problem described in the bug. + + def test_04_NB224760_too_long_filter(self): + """ + NB#224760 - 'too many sql variables' when filter ?sth in (long list) + """ + query = "SELECT tracker:id (?m) ?m WHERE { ?m a rdfs:Resource. FILTER (tracker:id (?m) in (%s)) }" + numbers = ",".join([str(i) for i in range(1000, 2000)]) + + results = self.tracker.query(query % (numbers)) + + # The query will raise an exception is the bug is there + # If we are here, everything is fine. + self.assertIsNotNone(results) + + def test_05_NB281201_insert_replace_and_superproperties(self): + """ + Bug 281201 - INSERT OR REPLACE does not delete previous values for superproperties + """ + content = """INSERT { <test:resource:nb281201> a nie:InformationElement; nie:contentLastModified '2011-09-27T11:11:11Z'. }""" - self.tracker.update (content) + self.tracker.update(content) - query = """SELECT ?contentLM ?nieIEDate ?dcDate { + query = """SELECT ?contentLM ?nieIEDate ?dcDate { <test:resource:nb281201> dc:date ?dcDate ; nie:informationElementDate ?nieIEDate ; nie:contentLastModified ?contentLM . }""" - result = self.tracker.query (query) - # Only one row of results, and the 3 colums have the same value - self.assertEqual (len (result), 1) - self.assertEqual (result[0][0], result[0][1]) - self.assertEqual (result[0][1], result[0][2]) + result = self.tracker.query(query) + # Only one row of results, and the 3 colums have the same value + self.assertEqual(len(result), 1) + self.assertEqual(result[0][0], result[0][1]) + self.assertEqual(result[0][1], result[0][2]) - problematic = """INSERT OR REPLACE { + problematic = """INSERT OR REPLACE { <test:resource:nb281201> nie:contentLastModified '2012-10-28T12:12:12' }""" - - self.tracker.update (problematic) - result = self.tracker.query (query) - # Only one row of results, and the 3 colums have the same value - self.assertEqual (len (result), 1) - self.assertEqual (result[0][0], result[0][1]) - self.assertEqual (result[0][1], result[0][2]) - + self.tracker.update(problematic) + result = self.tracker.query(query) + # Only one row of results, and the 3 colums have the same value + self.assertEqual(len(result), 1) + self.assertEqual(result[0][0], result[0][1]) + self.assertEqual(result[0][1], result[0][2]) if __name__ == "__main__": - ut.main() + ut.main() diff --git a/tests/functional-tests/03-fts-functions.py b/tests/functional-tests/03-fts-functions.py index 98086a35e..df2668b22 100755 --- a/tests/functional-tests/03-fts-functions.py +++ b/tests/functional-tests/03-fts-functions.py @@ -25,12 +25,13 @@ and run sparql with fts functions to check the results. import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TestFTSFunctions (CommonTrackerStoreTest): """ Insert data with text and check the fts:xxxx functions are returning the expected results """ @ut.skip("Test currently fails.") - def test_fts_rank (self): + def test_fts_rank(self): """ 1. Insert a Contact1 with 'abcdefxyz' as fullname and nickname 2. Insert a Contact2 with 'abcdefxyz' as fullname @@ -53,7 +54,7 @@ class TestFTSFunctions (CommonTrackerStoreTest): nco:nickname 'abcdefxyz abcdefxyz' . } """ - self.tracker.update (insert_sparql) + self.tracker.update(insert_sparql) query = """ SELECT ?contact WHERE { @@ -61,12 +62,12 @@ class TestFTSFunctions (CommonTrackerStoreTest): fts:match 'abcdefxyz' . } ORDER BY DESC (fts:rank(?contact)) """ - results = self.tracker.query (query) + results = self.tracker.query(query) - self.assertEqual (len(results), 3) - self.assertEqual (results[0][0], "contact://test/fts-function/rank/1") - self.assertEqual (results[1][0], "contact://test/fts-function/rank/2") - self.assertEqual (results[2][0], "contact://test/fts-function/rank/3") + self.assertEqual(len(results), 3) + self.assertEqual(results[0][0], "contact://test/fts-function/rank/1") + self.assertEqual(results[1][0], "contact://test/fts-function/rank/2") + self.assertEqual(results[2][0], "contact://test/fts-function/rank/3") delete_sparql = """ DELETE { @@ -75,10 +76,9 @@ class TestFTSFunctions (CommonTrackerStoreTest): <contact://test/fts-function/rank/3> a rdfs:Resource . } """ - self.tracker.update (delete_sparql) - + self.tracker.update(delete_sparql) - def test_fts_offsets (self): + def test_fts_offsets(self): """ 1. Insert a Contact1 with 'abcdefxyz' as fullname and nickname 2. Insert a Contact2 with 'abcdefxyz' as fullname @@ -101,7 +101,7 @@ class TestFTSFunctions (CommonTrackerStoreTest): nco:nickname 'abcdefxyz abcdefxyz' . } """ - self.tracker.update (insert_sparql) + self.tracker.update(insert_sparql) query = """ SELECT fts:offsets (?contact) WHERE { @@ -109,12 +109,13 @@ class TestFTSFunctions (CommonTrackerStoreTest): fts:match 'abcdefxyz' . } """ - results = self.tracker.query (query) + results = self.tracker.query(query) - self.assertEqual (len(results), 3) - self.assertEqual (results[0][0], 'nco:fullname,0,nco:nickname,0') - self.assertEqual (results[1][0], 'nco:fullname,0') - self.assertEqual (results[2][0], 'nco:fullname,0,nco:nickname,0,nco:nickname,10') + self.assertEqual(len(results), 3) + self.assertEqual(results[0][0], 'nco:fullname,0,nco:nickname,0') + self.assertEqual(results[1][0], 'nco:fullname,0') + self.assertEqual( + results[2][0], 'nco:fullname,0,nco:nickname,0,nco:nickname,10') delete_sparql = """ DELETE { @@ -123,7 +124,7 @@ class TestFTSFunctions (CommonTrackerStoreTest): <contact://test/fts-function/offset/3> a rdfs:Resource . } """ - self.tracker.update (delete_sparql) + self.tracker.update(delete_sparql) if __name__ == '__main__': diff --git a/tests/functional-tests/04-group-concat.py b/tests/functional-tests/04-group-concat.py index 2bdf8503a..3ae53239a 100755 --- a/tests/functional-tests/04-group-concat.py +++ b/tests/functional-tests/04-group-concat.py @@ -23,20 +23,22 @@ Test the GROUP_CONCAT function in Sparql. Only requires the store. import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TestGroupConcat (CommonTrackerStoreTest): """ Insert a multivalued property and request the results in GROUP_CONCAT """ - def test_group_concat (self): + + def test_group_concat(self): """ 1. Insert 3 capabilities for a test contact 2. Retrieve contact/capabilites without group_contact (3 results) 2. TEST: contact with group_concat capabilities (1 result) 3. Remove the test contact inserted """ - + uri = "contact://test_group_concat" - + insert = """ INSERT { <%s> a nco:IMAddress; nco:imID \"test_group_concat\"; @@ -45,7 +47,7 @@ class TestGroupConcat (CommonTrackerStoreTest): nco:imCapability nco:im-capability-file-transfers . } """ % (uri) - self.tracker.update (insert) + self.tracker.update(insert) query = """ SELECT ?c ?capability WHERE { @@ -53,23 +55,23 @@ class TestGroupConcat (CommonTrackerStoreTest): nco:imID \"test_group_concat\"; nco:imCapability ?capability . } - """ - results = self.tracker.query (query) + """ + results = self.tracker.query(query) - assert len (results) == 3 + assert len(results) == 3 group_concat_query = """ SELECT ?c GROUP_CONCAT (?capability, '|') AS ?cap WHERE { ?c a nco:IMAddress ; nco:imID \"test_group_concat\"; nco:imCapability ?capability . } GROUP BY (?c) - """ - results = self.tracker.query (group_concat_query) - assert len (results) == 1 - - instances = results[0][1].split ('|') - assert len (instances) == 3 - + """ + results = self.tracker.query(group_concat_query) + assert len(results) == 1 + + instances = results[0][1].split('|') + assert len(instances) == 3 + TEXT_CHAT = "http://www.semanticdesktop.org/ontologies/2007/03/22/nco#im-capability-text-chat" MEDIA_CALLS = "http://www.semanticdesktop.org/ontologies/2007/03/22/nco#im-capability-media-calls" FILE_TRANSFERS = "http://www.semanticdesktop.org/ontologies/2007/03/22/nco#im-capability-file-transfers" @@ -77,14 +79,13 @@ class TestGroupConcat (CommonTrackerStoreTest): assert MEDIA_CALLS in instances assert FILE_TRANSFERS in instances - #self.assertEquals (str(results[0][0]), "test_insertion_1") delete = """ DELETE { <%s> a rdfs:Resource. } """ % (uri) - self.tracker.update (delete) - + self.tracker.update(delete) + if __name__ == '__main__': ut.main() diff --git a/tests/functional-tests/05-coalesce.py b/tests/functional-tests/05-coalesce.py index 6a3a6e302..a9ef15aab 100755 --- a/tests/functional-tests/05-coalesce.py +++ b/tests/functional-tests/05-coalesce.py @@ -23,13 +23,14 @@ Test tracker:coalesce function in Sparql. Only uses the Store import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TestCoalesce (CommonTrackerStoreTest): """ Insert and instance with some values, and tracker coalesce of some of them with different combinations (first NULL, none NULL, all NULL...) """ - def setUp (self): + def setUp(self): self.resource_uri = "contact://test_group_concat" # @@ -41,17 +42,15 @@ class TestCoalesce (CommonTrackerStoreTest): nco:nameFamily \"family name\" . } """ % (self.resource_uri) - self.tracker.update (insert) + self.tracker.update(insert) - def tearDown (self): + def tearDown(self): delete = """ DELETE { <%s> a rdfs:Resource. } """ % (self.resource_uri) - self.tracker.update (delete) - + self.tracker.update(delete) - - def test_coalesce_first_fine (self): + def test_coalesce_first_fine(self): """ setUp: Insert a contact with only some text properties set 1. TEST: run a query with coalesce with the valid value in first position @@ -67,13 +66,12 @@ class TestCoalesce (CommonTrackerStoreTest): OPTIONAL { ?c nco:note ?note } FILTER (?c != nco:default-contact-me && ?c != nco:default-contact-emergency) } - """ - results = self.tracker.query (query) - assert len (results) == 1 + """ + results = self.tracker.query(query) + assert len(results) == 1 assert results[0][0] == "full name" - - def test_coalesce_second_fine (self): + def test_coalesce_second_fine(self): """ setUp: Insert a contact with only some text properties set 1. TEST: run a query with coalesce. First property NULL, second fine @@ -89,13 +87,12 @@ class TestCoalesce (CommonTrackerStoreTest): OPTIONAL { ?c nco:note ?note } FILTER (?c != nco:default-contact-me && ?c != nco:default-contact-emergency) } - """ - results = self.tracker.query (query) - assert len (results) == 1 + """ + results = self.tracker.query(query) + assert len(results) == 1 assert results[0][0] == "family name" - - def test_coalesce_none_fine_default (self): + def test_coalesce_none_fine_default(self): """ setUp: Insert a contact with only some text properties set 1. TEST: run a query with coalesce. all variables NULL, return default value @@ -111,11 +108,11 @@ class TestCoalesce (CommonTrackerStoreTest): OPTIONAL { ?c nco:note ?note } FILTER (?c != nco:default-contact-me && ?c != nco:default-contact-emergency) } - """ - results = self.tracker.query (query) - assert len (results) == 1 + """ + results = self.tracker.query(query) + assert len(results) == 1 assert results[0][0] == "test_coalesce" - + if __name__ == '__main__': ut.main() diff --git a/tests/functional-tests/06-distance.py b/tests/functional-tests/06-distance.py index f3e0da55e..52191559f 100755 --- a/tests/functional-tests/06-distance.py +++ b/tests/functional-tests/06-distance.py @@ -25,13 +25,15 @@ from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreT POINT_COORDS = [ (0, 0), (1, 1), (2, 2), (3, 3), (4, 4) - ] +] + class TestDistanceFunctions (CommonTrackerStoreTest): """ Insert some points and get the distance between them. """ - def setUp (self): + + def setUp(self): self.counter = 0 for lat, log in POINT_COORDS: insert = """ @@ -41,25 +43,24 @@ class TestDistanceFunctions (CommonTrackerStoreTest): mlo:latitude %d . } """ % ("point://test/point/" + str(self.counter), log, lat) - self.tracker.update (insert) + self.tracker.update(insert) self.counter += 1 - def tearDown (self): - for i in range (0, self.counter): + def tearDown(self): + for i in range(0, self.counter): delete = """ DELETE { <%s> a rdfs:Resource. } """ % ("point://test/point/" + str (i)) - self.tracker.update (delete) - + self.tracker.update(delete) - def get_distance_between_points (self, sum_func, id1, id2): + def get_distance_between_points(self, sum_func, id1, id2): - assert 0 <= id1 <= len (POINT_COORDS) - assert 0 <= id2 <= len (POINT_COORDS) + assert 0 <= id1 <= len(POINT_COORDS) + assert 0 <= id2 <= len(POINT_COORDS) assert sum_func == "cartesian" or sum_func == "haversine" - + query_1_to_2 = """ SELECT xsd:integer(tracker:%s-distance(?lat1,?lat2,?lon1,?lon2)) WHERE { @@ -72,58 +73,56 @@ class TestDistanceFunctions (CommonTrackerStoreTest): mlo:longitude ?lon2 . } """ % (sum_func, id1, id2) - result = self.tracker.query (query_1_to_2) - return int (result[0][0]) - - - def test_distance_cartesian_symmetry (self): + result = self.tracker.query(query_1_to_2) + return int(result[0][0]) + + def test_distance_cartesian_symmetry(self): """ setUp: Insert 5 points in the pre-defined coordinates 1. TEST: Check cartesian distance from point A to B, and from B to A (should be the same :P) tearDown: Remove the test points inserted before """ - a_to_b = self.get_distance_between_points ("cartesian", 1, 2) + a_to_b = self.get_distance_between_points("cartesian", 1, 2) assert a_to_b == 204601 - b_to_a = self.get_distance_between_points ("cartesian", 2, 1) + b_to_a = self.get_distance_between_points("cartesian", 2, 1) assert b_to_a == 204601 - assert a_to_b == b_to_a + assert a_to_b == b_to_a - def test_distance_haversine_symmetry (self): + def test_distance_haversine_symmetry(self): """ setUp: Insert 5 points in the pre-defined coordinates 1. TEST: Check cartesian distance from point A to B, and from B to A (should be the same :P) tearDown: Remove the test points inserted before """ - a_to_b = self.get_distance_between_points ("haversine", 1, 2) + a_to_b = self.get_distance_between_points("haversine", 1, 2) assert a_to_b == 157225 - - b_to_a = self.get_distance_between_points ("haversine", 2, 1) + + b_to_a = self.get_distance_between_points("haversine", 2, 1) assert b_to_a == 157225 assert a_to_b == b_to_a - - def test_distance_cartesian_proportion (self): - d_1_to_2 = self.get_distance_between_points ("cartesian", 1, 2) - d_2_to_3 = self.get_distance_between_points ("cartesian", 2, 3) - d_3_to_4 = self.get_distance_between_points ("cartesian", 3, 4) + def test_distance_cartesian_proportion(self): + d_1_to_2 = self.get_distance_between_points("cartesian", 1, 2) + d_2_to_3 = self.get_distance_between_points("cartesian", 2, 3) + d_3_to_4 = self.get_distance_between_points("cartesian", 3, 4) assert d_1_to_2 > d_2_to_3 > d_3_to_4 - def test_distance_haversine_proportion (self): - d_1_to_2 = self.get_distance_between_points ("haversine", 1, 2) - d_2_to_3 = self.get_distance_between_points ("haversine", 2, 3) - d_3_to_4 = self.get_distance_between_points ("haversine", 3, 4) + def test_distance_haversine_proportion(self): + d_1_to_2 = self.get_distance_between_points("haversine", 1, 2) + d_2_to_3 = self.get_distance_between_points("haversine", 2, 3) + d_3_to_4 = self.get_distance_between_points("haversine", 3, 4) assert d_1_to_2 > d_2_to_3 > d_3_to_4 - def test_distance_different (self): - d_2_to_3h = self.get_distance_between_points ("haversine", 2, 3) - d_2_to_3c = self.get_distance_between_points ("cartesian", 2, 3) + def test_distance_different(self): + d_2_to_3h = self.get_distance_between_points("haversine", 2, 3) + d_2_to_3c = self.get_distance_between_points("cartesian", 2, 3) assert d_2_to_3h < d_2_to_3c - + if __name__ == '__main__': ut.main() diff --git a/tests/functional-tests/07-graph.py b/tests/functional-tests/07-graph.py index 1ea6a6a5e..03366fd30 100755 --- a/tests/functional-tests/07-graph.py +++ b/tests/functional-tests/07-graph.py @@ -23,13 +23,14 @@ Tests graphs in Sparql. Only requires the store. import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TestGraphs (CommonTrackerStoreTest): """ Insert triplets in different graphs and check the query results asking in one specific graph, in all of them and so on. """ - def test_graph_filter (self): + def test_graph_filter(self): """ 1. Insert a contact with different phone numbers from different sources 2. Query phone numbers of a single graph @@ -56,7 +57,7 @@ class TestGraphs (CommonTrackerStoreTest): } } """ - self.tracker.update (insert_sparql) + self.tracker.update(insert_sparql) query = """ SELECT ?contact ?number WHERE { @@ -66,11 +67,11 @@ class TestGraphs (CommonTrackerStoreTest): } } ORDER BY DESC (fts:rank(?contact)) """ - results = self.tracker.query (query) + results = self.tracker.query(query) - self.assertEqual (len(results), 1) - self.assertEqual (results[0][0], "contact://test/graph/1") - self.assertEqual (results[0][1], "tel:+1234567891") + self.assertEqual(len(results), 1) + self.assertEqual(results[0][0], "contact://test/graph/1") + self.assertEqual(results[0][1], "tel:+1234567891") delete_sparql = """ DELETE { @@ -81,7 +82,7 @@ class TestGraphs (CommonTrackerStoreTest): } """ - def test_graph_insert_multiple (self): + def test_graph_insert_multiple(self): """ 1. Insert a contact with the same phone number from different sources 2. Query graph uri of hasPhoneNumber statement @@ -104,7 +105,7 @@ class TestGraphs (CommonTrackerStoreTest): } } """ - self.tracker.update (insert_sparql) + self.tracker.update(insert_sparql) query = """ SELECT ?contact ?g WHERE { @@ -114,10 +115,10 @@ class TestGraphs (CommonTrackerStoreTest): } } """ - results = self.tracker.query (query) - self.assertEqual (len(results), 1) - self.assertEqual (results[0][0], "contact://test/graph/1") - self.assertEqual (results[0][1], "graph://test/graph/0") + results = self.tracker.query(query) + self.assertEqual(len(results), 1) + self.assertEqual(results[0][0], "contact://test/graph/1") + self.assertEqual(results[0][1], "graph://test/graph/0") delete_sparql = """ DELETE { @@ -127,6 +128,5 @@ class TestGraphs (CommonTrackerStoreTest): """ - if __name__ == '__main__': ut.main() diff --git a/tests/functional-tests/08-unique-insertions.py b/tests/functional-tests/08-unique-insertions.py index a5ea446d9..23650231f 100755 --- a/tests/functional-tests/08-unique-insertions.py +++ b/tests/functional-tests/08-unique-insertions.py @@ -23,13 +23,14 @@ Replicate the behaviour of the miner inserting information in the store. import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TestMinerInsertBehaviour (CommonTrackerStoreTest): """ Mimic the behaviour of the miner, removing the previous information of the resource and inserting a new one. """ - def test_miner_unique_insertion (self): + def test_miner_unique_insertion(self): """ We actually can't test tracker-miner-fs, so we mimick its behavior in this test 1. Insert one resource @@ -57,22 +58,22 @@ class TestMinerInsertBehaviour (CommonTrackerStoreTest): """ ''' First insertion ''' - self.tracker.update (insert_sparql) + self.tracker.update(insert_sparql) - results = self.tracker.query (select_sparql) - self.assertEqual (len(results), 1) + results = self.tracker.query(select_sparql) + self.assertEqual(len(results), 1) ''' Second insertion / update ''' - self.tracker.update (insert_sparql) + self.tracker.update(insert_sparql) - results = self.tracker.query (select_sparql) - self.assertEqual (len(results), 1) + results = self.tracker.query(select_sparql) + self.assertEqual(len(results), 1) ''' Clean up ''' - self.tracker.update (delete_sparql) + self.tracker.update(delete_sparql) - results = self.tracker.query (select_sparql) - self.assertEqual (len(results), 0) + results = self.tracker.query(select_sparql) + self.assertEqual(len(results), 0) if __name__ == '__main__': diff --git a/tests/functional-tests/09-concurrent-query.py b/tests/functional-tests/09-concurrent-query.py index 8e4a97292..f362dc98d 100755 --- a/tests/functional-tests/09-concurrent-query.py +++ b/tests/functional-tests/09-concurrent-query.py @@ -28,42 +28,44 @@ from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreT AMOUNT_OF_TEST_INSTANCES = 100 AMOUNT_OF_QUERIES = 10 + class TestConcurrentQuery (CommonTrackerStoreTest): """ Send a bunch of queries to the daemon asynchronously, to test the queue holding those queries """ - def setUp (self): - self.main_loop = GLib.MainLoop () - - self.mock_data_insert () + + def setUp(self): + self.main_loop = GLib.MainLoop() + + self.mock_data_insert() self.finish_counter = 0 - - def mock_data_insert (self): + + def mock_data_insert(self): query = "INSERT {\n" - for i in range (0, AMOUNT_OF_TEST_INSTANCES): - query += "<test-09:instance-%d> a nco:PersonContact ; nco:fullname 'moe %d'.\n" % (i, i) + for i in range(0, AMOUNT_OF_TEST_INSTANCES): + query += "<test-09:instance-%d> a nco:PersonContact ; nco:fullname 'moe %d'.\n" % ( + i, i) query += "}" - self.tracker.update (query) - - def mock_data_delete (self): + self.tracker.update(query) + + def mock_data_delete(self): query = "DELETE {\n" - for i in range (0, AMOUNT_OF_TEST_INSTANCES): + for i in range(0, AMOUNT_OF_TEST_INSTANCES): query += "<test-09:instance-%d> a rdfs:Resource.\n" % (i) query += "}" - self.tracker.update (query) + self.tracker.update(query) query = "DELETE {\n" - for i in range (0, AMOUNT_OF_QUERIES): + for i in range(0, AMOUNT_OF_QUERIES): query += "<test-09:picture-%d> a rdfs:Resource.\n" % (i) query += "}" - self.tracker.update (query) - + self.tracker.update(query) - def test_async_queries (self): + def test_async_queries(self): QUERY = "SELECT ?u WHERE { ?u a nco:PersonContact. FILTER regex (?u, 'test-09:ins')}" UPDATE = "INSERT { <test-09:picture-%d> a nmm:Photo. }" - for i in range (0, AMOUNT_OF_QUERIES): + for i in range(0, AMOUNT_OF_QUERIES): self.tracker.query( QUERY, result_handler=self.reply_cb, @@ -74,26 +76,26 @@ class TestConcurrentQuery (CommonTrackerStoreTest): error_handler=self.error_handler) # Safeguard of 60 seconds. The last reply should quit the loop - GLib.timeout_add_seconds (60, self.timeout_cb) - self.main_loop.run () - - def reply_cb (self, obj, results, data): + GLib.timeout_add_seconds(60, self.timeout_cb) + self.main_loop.run() + + def reply_cb(self, obj, results, data): self.finish_counter += 1 - self.assertEqual (len (results), AMOUNT_OF_TEST_INSTANCES) + self.assertEqual(len(results), AMOUNT_OF_TEST_INSTANCES) if (self.finish_counter >= AMOUNT_OF_QUERIES): - self.timeout_cb () + self.timeout_cb() - def update_cb (self, obj, results, data): - self.assertTrue (True) + def update_cb(self, obj, results, data): + self.assertTrue(True) - def error_handler (self, obj, e, user_data): + def error_handler(self, obj, e, user_data): print("ERROR in DBus call: %s" % e) raise(e) - def timeout_cb (self): - self.mock_data_delete () - self.main_loop.quit () + def timeout_cb(self): + self.mock_data_delete() + self.main_loop.quit() return False if __name__ == "__main__": - ut.main () + ut.main() diff --git a/tests/functional-tests/10-sqlite-misused.py b/tests/functional-tests/10-sqlite-misused.py index c08751d15..cb0a7cec2 100755 --- a/tests/functional-tests/10-sqlite-misused.py +++ b/tests/functional-tests/10-sqlite-misused.py @@ -28,35 +28,37 @@ from common.utils import configuration as cfg import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TestSqliteMisused (CommonTrackerStoreTest): """ Send queries while importing files (in .ttl directory) """ - def setUp (self): - self.main_loop = GLib.MainLoop () + + def setUp(self): + self.main_loop = GLib.MainLoop() self.files_counter = 0 - def test_queries_while_import (self): + def test_queries_while_import(self): assert os.path.isdir(cfg.generated_ttl_dir()) for root, dirs, files in os.walk(cfg.generated_ttl_dir()): - for ttl_file in [f for f in files if f.endswith (".ttl")]: - full_path = os.path.abspath(os.path.join (root, ttl_file)) + for ttl_file in [f for f in files if f.endswith(".ttl")]: + full_path = os.path.abspath(os.path.join(root, ttl_file)) self.files_counter += 1 self.tracker.load( "file://" + full_path, timeout=30000, result_handler=self.loaded_success_cb, error_handler=self.loaded_failed_cb, - user_data = full_path) + user_data=full_path) - GLib.timeout_add_seconds (2, self.run_a_query) + GLib.timeout_add_seconds(2, self.run_a_query) # Safeguard of 60 seconds. The last reply should quit the loop # It doesn't matter if we didn't import all of the files yet. - GLib.timeout_add_seconds (60, self.timeout_cb) - self.main_loop.run () + GLib.timeout_add_seconds(60, self.timeout_cb) + self.main_loop.run() - def run_a_query (self): + def run_a_query(self): QUERY = "SELECT ?u ?title WHERE { ?u a nie:InformationElement; nie:title ?title. }" self.tracker.query( QUERY, timeout=20000, @@ -64,26 +66,26 @@ class TestSqliteMisused (CommonTrackerStoreTest): error_handler=self.error_handler) return True - def reply_cb (self, obj, results, data): + def reply_cb(self, obj, results, data): print("Query replied correctly") - def error_handler (self, obj, error, data): + def error_handler(self, obj, error, data): print("ERROR in DBus call: %s" % error) - def loaded_success_cb (self, obj, results, user_data): + def loaded_success_cb(self, obj, results, user_data): self.files_counter -= 1 if (self.files_counter == 0): print("Last file loaded") - self.timeout_cb () + self.timeout_cb() print("Success loading %s" % user_data) - def loaded_failed_cb (self, obj, error, user_data): + def loaded_failed_cb(self, obj, error, user_data): raise RuntimeError("Failed loading %s: %s" % (user_data, error)) - def timeout_cb (self): + def timeout_cb(self): print("Forced timeout after 60 sec.") - self.main_loop.quit () + self.main_loop.quit() return False if __name__ == "__main__": - ut.main () + ut.main() diff --git a/tests/functional-tests/11-sqlite-batch-misused.py b/tests/functional-tests/11-sqlite-batch-misused.py index 4053d584f..fad38ba19 100755 --- a/tests/functional-tests/11-sqlite-batch-misused.py +++ b/tests/functional-tests/11-sqlite-batch-misused.py @@ -31,31 +31,33 @@ from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreT # Number of instances per batch BATCH_SIZE = 3000 + class TestSqliteBatchMisused (CommonTrackerStoreTest): """ Send big batchSparqlUpdates and run queries at the same time Don't run this script directly, use the bash script "force-sqlite-misused.sh" instead to configure properly the environment """ - def setUp (self): - self.main_loop = GLib.MainLoop () + + def setUp(self): + self.main_loop = GLib.MainLoop() self.batch_counter = 0 - def test_queries_while_batch_insert (self): - self.assertTrue (os.path.exists (cfg.generated_ttl_dir())) + def test_queries_while_batch_insert(self): + self.assertTrue(os.path.exists(cfg.generated_ttl_dir())) for root, dirs, files in os.walk(cfg.generated_ttl_dir()): - for ttl_file in [f for f in files if f.endswith (".ttl")]: - full_path = os.path.abspath(os.path.join (root, ttl_file)) + for ttl_file in [f for f in files if f.endswith(".ttl")]: + full_path = os.path.abspath(os.path.join(root, ttl_file)) print(full_path) counter = 0 current_batch = "" for line in open(full_path): - if (line.startswith ("@prefix")): + if (line.startswith("@prefix")): continue current_batch += line - if len(line) > 1 and line[:-1].endswith ('.'): + if len(line) > 1 and line[:-1].endswith('.'): counter += 1 if counter >= BATCH_SIZE: @@ -65,17 +67,17 @@ class TestSqliteBatchMisused (CommonTrackerStoreTest): timeout=20000, result_handler=self.batch_success_cb, error_handler=self.batch_failed_cb) - self.run_a_query () + self.run_a_query() counter = 0 current_batch = "" self.batch_counter += 1 - GLib.timeout_add_seconds (2, self.run_a_query) + GLib.timeout_add_seconds(2, self.run_a_query) # Safeguard of 60 seconds. The last reply should quit the loop - GLib.timeout_add_seconds (60, self.timeout_cb) - self.main_loop.run () + GLib.timeout_add_seconds(60, self.timeout_cb) + self.main_loop.run() - def run_a_query (self): + def run_a_query(self): QUERY = "SELECT ?u ?title WHERE { ?u a nie:InformationElement; nie:title ?title. }" self.tracker.query( QUERY, timeout=20000, @@ -83,28 +85,28 @@ class TestSqliteBatchMisused (CommonTrackerStoreTest): error_handler=self.error_handler) return True - def reply_cb (self, obj, results, data): + def reply_cb(self, obj, results, data): print("Query replied correctly") - def error_handler (self, error_msg): + def error_handler(self, error_msg): print("Query failed", error_msg) raise error_msg - def batch_success_cb (self, obj, result, user_data): + def batch_success_cb(self, obj, result, user_data): self.batch_counter -= 1 if (self.batch_counter == 0): print("Last batch was success") - self.timeout_cb () + self.timeout_cb() print("Success processing a batch") - def batch_failed_cb (self, obj, error, user_data): + def batch_failed_cb(self, obj, error, user_data): print("Failed processing a batch: %s" % error) raise error - def timeout_cb (self): + def timeout_cb(self): print("Forced timeout after 60 sec.") - self.main_loop.quit () + self.main_loop.quit() return False if __name__ == "__main__": - ut.main () + ut.main() diff --git a/tests/functional-tests/12-transactions.py b/tests/functional-tests/12-transactions.py index 3264da7d2..5f6d870d3 100755 --- a/tests/functional-tests/12-transactions.py +++ b/tests/functional-tests/12-transactions.py @@ -27,6 +27,7 @@ from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreT TEST_INSTANCE_PATTERN = "test://12-transactions-%d" + class TrackerTransactionsTest (CommonTrackerStoreTest): """ In a loop: @@ -38,49 +39,49 @@ class TrackerTransactionsTest (CommonTrackerStoreTest): If the commit was real, all the inserted instances should be there. """ - def setUp (self): + def setUp(self): self.instance_counter = 0 - def tearDown (self): + def tearDown(self): print("Tear down (will take some time to remove all resources)") delete_sparql = "DELETE { ?u a rdfs:Resource } WHERE { ?u a nmo:Email} \n" - self.tracker.update (delete_sparql, - timeout=60000) + self.tracker.update(delete_sparql, + timeout=60000) self.instance_counter = 0 - def insert_and_commit (self, number): + def insert_and_commit(self, number): insert_sparql = "INSERT {\n" - for i in range (0, number): - insert_sparql += " <" + TEST_INSTANCE_PATTERN % (self.instance_counter) + ">" + for i in range(0, number): + insert_sparql += " <" + \ + TEST_INSTANCE_PATTERN % (self.instance_counter) + ">" insert_sparql += " a nmo:Email.\n " self.instance_counter += 1 insert_sparql += "}" - self.tracker.batch_update (insert_sparql) - #print "Waiting for commit (", number," instances)" + self.tracker.batch_update(insert_sparql) + # print "Waiting for commit (", number," instances)" #start = time.time () - self.tracker.batch_commit () + self.tracker.batch_commit() #end = time.time () - #print "BatchCommit returned (after %d s.)" % (end - start) - + # print "BatchCommit returned (after %d s.)" % (end - start) - def test_commit_and_abort (self): + def test_commit_and_abort(self): - for i in range (0, 20): + for i in range(0, 20): NUMBER_OF_INSTANCES = 1000 - self.insert_and_commit (NUMBER_OF_INSTANCES) + self.insert_and_commit(NUMBER_OF_INSTANCES) self.tracker.kill() self.tracker.start() try: - results = self.tracker.count_instances ("nmo:Email") + results = self.tracker.count_instances("nmo:Email") except: print("Timeout, probably replaying journal or something (wait 20 sec.)") - time.sleep (20) - results = self.tracker.count_instances () + time.sleep(20) + results = self.tracker.count_instances() # Every iteration we are adding new instances in the store! - self.assertEqual (results, NUMBER_OF_INSTANCES * (i+1)) + self.assertEqual(results, NUMBER_OF_INSTANCES * (i + 1)) if __name__ == "__main__": - ut.main () + ut.main() diff --git a/tests/functional-tests/13-threaded-store.py b/tests/functional-tests/13-threaded-store.py index 0cd8f427b..d3fb88023 100755 --- a/tests/functional-tests/13-threaded-store.py +++ b/tests/functional-tests/13-threaded-store.py @@ -29,11 +29,14 @@ from common.utils import configuration as cfg import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest -MAX_TEST_TIME = 60 # seconds to finish the tests (to avoid infinite waitings) +MAX_TEST_TIME = 60 # seconds to finish the tests (to avoid infinite waitings) + +AMOUNT_SIMPLE_QUERIES = 10 +# ms (How long do we wait for an answer to the complex query) +COMPLEX_QUERY_TIMEOUT = 15000 +# seconds (How freq do we send a simple query to the daemon) +SIMPLE_QUERY_FREQ = 2 -AMOUNT_SIMPLE_QUERIES = 10 -COMPLEX_QUERY_TIMEOUT = 15000 # ms (How long do we wait for an answer to the complex query) -SIMPLE_QUERY_FREQ = 2 # seconds (How freq do we send a simple query to the daemon) class TestThreadedStore (CommonTrackerStoreTest): """ @@ -42,14 +45,15 @@ class TestThreadedStore (CommonTrackerStoreTest): Reported in bug NB#183499 """ - def setUp (self): - self.main_loop = GLib.MainLoop () + + def setUp(self): + self.main_loop = GLib.MainLoop() self.simple_queries_counter = AMOUNT_SIMPLE_QUERIES self.simple_queries_answers = 0 - def __populate_database (self): + def __populate_database(self): - self.assertTrue (os.path.exists (cfg.generated_ttl_dir())) + self.assertTrue(os.path.exists(cfg.generated_ttl_dir())) for ttl_file in ["010-nco_EmailAddress.ttl", "011-nco_PostalAddress.ttl", "012-nco_PhoneNumber.ttl", @@ -58,17 +62,18 @@ class TestThreadedStore (CommonTrackerStoreTest): "018-nco_PersonContact.ttl", "012-nco_PhoneNumber.ttl", "016-nco_ContactIM.ttl"]: - full_path = os.path.abspath(os.path.join (cfg.generated_ttl_dir(), ttl_file)) + full_path = os.path.abspath(os.path.join( + cfg.generated_ttl_dir(), ttl_file)) print(full_path) self.tracker.get_tracker_iface().Load( '(s)', "file://" + full_path, timeout=30000) @ut.skip("Test fails with 'GDBus.Error:org.freedesktop.Tracker1.SparqlError.Internal: parser stack overflow (36)'") - def test_complex_query (self): - start = time.time () - self.__populate_database () - end = time.time () - print("Loading: %.3f sec." % (end-start)) + def test_complex_query(self): + start = time.time() + self.__populate_database() + end = time.time() + print("Loading: %.3f sec." % (end - start)) COMPLEX_QUERY = """ SELECT ?url nie:url(?photo) nco:imStatusMessage (?url) @@ -94,17 +99,18 @@ class TestThreadedStore (CommonTrackerStoreTest): # Standard timeout print("Send complex query") - self.complex_start = time.time () + self.complex_start = time.time() self.tracker.query( COMPLEX_QUERY, timeout=COMPLEX_QUERY_TIMEOUT, response_handler=self.reply_complex, error_handler=self.error_handler_complex) - self.timeout_id = GLib.timeout_add_seconds (MAX_TEST_TIME, self.__timeout_on_idle) - GLib.timeout_add_seconds (SIMPLE_QUERY_FREQ, self.__simple_query) - self.main_loop.run () + self.timeout_id = GLib.timeout_add_seconds( + MAX_TEST_TIME, self.__timeout_on_idle) + GLib.timeout_add_seconds(SIMPLE_QUERY_FREQ, self.__simple_query) + self.main_loop.run() - def __simple_query (self): + def __simple_query(self): print("Send simple query (%d)" % (self.simple_queries_counter)) SIMPLE_QUERY = "SELECT ?name WHERE { ?u a nco:PersonContact; nco:fullname ?name. }" self.tracker.query( @@ -118,28 +124,28 @@ class TestThreadedStore (CommonTrackerStoreTest): return False return True - def reply_simple (self, obj, results, data): + def reply_simple(self, obj, results, data): print("Simple query answered") - self.assertNotEqual (len (results), 0) + self.assertNotEqual(len(results), 0) self.simple_queries_answers += 1 if (self.simple_queries_answers == AMOUNT_SIMPLE_QUERIES): print("All simple queries answered") - self.main_loop.quit () + self.main_loop.quit() - def reply_complex (self, obj, results, data): - print("Complex query: %.3f" % (time.time () - self.complex_start)) + def reply_complex(self, obj, results, data): + print("Complex query: %.3f" % (time.time() - self.complex_start)) - def error_handler (self, error_msg): + def error_handler(self, error_msg): print("ERROR in dbus call", error_msg) - def error_handler_complex (self, error_msg): + def error_handler_complex(self, error_msg): print("Complex query timedout in DBus (", error_msg, ")") - def __timeout_on_idle (self): + def __timeout_on_idle(self): print("Timeout... asumming idle") - self.main_loop.quit () + self.main_loop.quit() return False - + if __name__ == "__main__": - ut.main () + ut.main() diff --git a/tests/functional-tests/14-signals.py b/tests/functional-tests/14-signals.py index 0924a04b1..44806e8a2 100755 --- a/tests/functional-tests/14-signals.py +++ b/tests/functional-tests/14-signals.py @@ -38,14 +38,16 @@ SIGNALS_IFACE = "org.freedesktop.Tracker1.Resources" CONTACT_CLASS_URI = "http://www.semanticdesktop.org/ontologies/2007/03/22/nco#PersonContact" -REASONABLE_TIMEOUT = 10 # Time waiting for the signal to be emitted +REASONABLE_TIMEOUT = 10 # Time waiting for the signal to be emitted + class TrackerStoreSignalsTests (CommonTrackerStoreTest): """ Insert/update/remove instances from nco:PersonContact and check that the signals are emitted """ - def setUp (self): + + def setUp(self): self.clean_up_list = [] self.loop = GLib.MainLoop() @@ -57,14 +59,13 @@ class TrackerStoreSignalsTests (CommonTrackerStoreTest): self.results_deletes = None self.results_inserts = None - def tearDown (self): + def tearDown(self): for uri in self.clean_up_list: - self.tracker.update ("DELETE { <%s> a rdfs:Resource }" % uri) + self.tracker.update("DELETE { <%s> a rdfs:Resource }" % uri) self.clean_up_list = [] - - def __connect_signal (self): + def __connect_signal(self): """ After connecting to the signal, call self.__wait_for_signal. """ @@ -77,23 +78,25 @@ class TrackerStoreSignalsTests (CommonTrackerStoreTest): flags=Gio.DBusSignalFlags.NONE, callback=self.__signal_received_cb) - def __wait_for_signal (self): + def __wait_for_signal(self): """ In the callback of the signals, there should be a self.loop.quit () """ - self.timeout_id = GLib.timeout_add_seconds (REASONABLE_TIMEOUT, self.__timeout_on_idle) - self.loop.run () + self.timeout_id = GLib.timeout_add_seconds( + REASONABLE_TIMEOUT, self.__timeout_on_idle) + self.loop.run() - def __timeout_on_idle (self): - self.loop.quit () - self.fail ("Timeout, the signal never came!") + def __timeout_on_idle(self): + self.loop.quit() + self.fail("Timeout, the signal never came!") - def __pretty_print_array (self, array): + def __pretty_print_array(self, array): for g, s, o, p in array: - uri, prop, value = self.tracker.query ("SELECT tracker:uri (%s), tracker:uri (%s), tracker:uri (%s) WHERE {}" % (s, o, p)) - print(" - (", "-".join ([g, uri, prop, value]), ")") - - def __signal_received_cb (self, connection, sender_name, object_path, interface_name, signal_name, parameters): + uri, prop, value = self.tracker.query( + "SELECT tracker:uri (%s), tracker:uri (%s), tracker:uri (%s) WHERE {}" % (s, o, p)) + print(" - (", "-".join([g, uri, prop, value]), ")") + + def __signal_received_cb(self, connection, sender_name, object_path, interface_name, signal_name, parameters): """ Save the content of the signal and disconnect the callback """ @@ -104,14 +107,13 @@ class TrackerStoreSignalsTests (CommonTrackerStoreTest): self.results_inserts = inserts if (self.timeout_id != 0): - GLib.source_remove (self.timeout_id ) + GLib.source_remove(self.timeout_id) self.timeout_id = 0 - self.loop.quit () + self.loop.quit() self.bus.signal_unsubscribe(self.cb_id) - - def test_01_insert_contact (self): - self.clean_up_list.append ("test://signals-contact-add") + def test_01_insert_contact(self): + self.clean_up_list.append("test://signals-contact-add") CONTACT = """ INSERT { <test://signals-contact-add> a nco:PersonContact ; @@ -122,16 +124,16 @@ class TrackerStoreSignalsTests (CommonTrackerStoreTest): nco:hasPhoneNumber <tel:555555555> . } """ - self.__connect_signal () - self.tracker.update (CONTACT) - time.sleep (1) - self.__wait_for_signal () + self.__connect_signal() + self.tracker.update(CONTACT) + time.sleep(1) + self.__wait_for_signal() # validate results - self.assertEqual (len (self.results_deletes), 0) - self.assertEqual (len (self.results_inserts), 6) - - def test_02_remove_contact (self): + self.assertEqual(len(self.results_deletes), 0) + self.assertEqual(len(self.results_inserts), 6) + + def test_02_remove_contact(self): CONTACT = """ INSERT { <test://signals-contact-remove> a nco:PersonContact ; @@ -139,56 +141,56 @@ class TrackerStoreSignalsTests (CommonTrackerStoreTest): nco:nameFamily 'Contact-family removed'. } """ - self.__connect_signal () - self.tracker.update (CONTACT) - self.__wait_for_signal () - - self.__connect_signal () + self.__connect_signal() + self.tracker.update(CONTACT) + self.__wait_for_signal() + + self.__connect_signal() self.tracker.update (""" DELETE { <test://signals-contact-remove> a rdfs:Resource } """) - self.__wait_for_signal () + self.__wait_for_signal() # Validate results: - self.assertEqual (len (self.results_deletes), 1) - self.assertEqual (len (self.results_inserts), 0) + self.assertEqual(len(self.results_deletes), 1) + self.assertEqual(len(self.results_inserts), 0) + + def test_03_update_contact(self): + self.clean_up_list.append("test://signals-contact-update") + self.__connect_signal() + self.tracker.update( + "INSERT { <test://signals-contact-update> a nco:PersonContact }") + self.__wait_for_signal() - def test_03_update_contact (self): - self.clean_up_list.append ("test://signals-contact-update") + self.__connect_signal() + self.tracker.update( + "INSERT { <test://signals-contact-update> nco:fullname 'wohoo'}") + self.__wait_for_signal() - self.__connect_signal () - self.tracker.update ("INSERT { <test://signals-contact-update> a nco:PersonContact }") - self.__wait_for_signal () - - self.__connect_signal () - self.tracker.update ("INSERT { <test://signals-contact-update> nco:fullname 'wohoo'}") - self.__wait_for_signal () + self.assertEqual(len(self.results_deletes), 0) + self.assertEqual(len(self.results_inserts), 1) - self.assertEqual (len (self.results_deletes), 0) - self.assertEqual (len (self.results_inserts), 1) + def test_04_fullupdate_contact(self): + self.clean_up_list.append("test://signals-contact-fullupdate") + self.__connect_signal() + self.tracker.update( + "INSERT { <test://signals-contact-fullupdate> a nco:PersonContact; nco:fullname 'first value' }") + self.__wait_for_signal() - def test_04_fullupdate_contact (self): - self.clean_up_list.append ("test://signals-contact-fullupdate") - - self.__connect_signal () - self.tracker.update ("INSERT { <test://signals-contact-fullupdate> a nco:PersonContact; nco:fullname 'first value' }") - self.__wait_for_signal () - - self.__connect_signal () + self.__connect_signal() self.tracker.update (""" DELETE { <test://signals-contact-fullupdate> nco:fullname ?x } WHERE { <test://signals-contact-fullupdate> a nco:PersonContact; nco:fullname ?x } INSERT { <test://signals-contact-fullupdate> nco:fullname 'second value'} """) - self.__wait_for_signal () + self.__wait_for_signal() + + self.assertEqual(len(self.results_deletes), 1) + self.assertEqual(len(self.results_inserts), 1) - self.assertEqual (len (self.results_deletes), 1) - self.assertEqual (len (self.results_inserts), 1) - if __name__ == "__main__": ut.main() - diff --git a/tests/functional-tests/15-statistics.py b/tests/functional-tests/15-statistics.py index 6fbc8210e..ac6a2f210 100755 --- a/tests/functional-tests/15-statistics.py +++ b/tests/functional-tests/15-statistics.py @@ -31,96 +31,97 @@ RDFS_RESOURCE = "rdfs:Resource" NIE_IE = "nie:InformationElement" RDFS_CLASS = "rdfs:Class" + class TrackerStoreStatisticsTests (CommonTrackerStoreTest): """ Check initial statistics, add, remove, update content and check results stats """ - def __get_stats (self): + + def __get_stats(self): results = {} - for classname, count in self.tracker.get_stats (): - results [str(classname)] = int(count) + for classname, count in self.tracker.get_stats(): + results[str(classname)] = int(count) return results - def setUp (self): + def setUp(self): """ Each test append to this list the used URIS, so they can be removed in the tearDown """ self.clean_up_instances = [] - def tearDown (self): + def tearDown(self): for uri in self.clean_up_instances: - self.tracker.update ("DELETE { <%s> a rdfs:Resource. }" % (uri)) + self.tracker.update("DELETE { <%s> a rdfs:Resource. }" % (uri)) self.clean_up_instances = [] - time.sleep (1) - - def test_stats_01_insert_base_class (self): - self.clean_up_instances.append ("test://stats-01") - - old_stats = self.__get_stats () - self.tracker.update ("INSERT { <test://stats-01> a nie:InformationElement. }") - new_stats = self.__get_stats () + time.sleep(1) + + def test_stats_01_insert_base_class(self): + self.clean_up_instances.append("test://stats-01") + + old_stats = self.__get_stats() + self.tracker.update( + "INSERT { <test://stats-01> a nie:InformationElement. }") + new_stats = self.__get_stats() increased_classes = [NIE_IE, RDFS_RESOURCE] - for k, v in new_stats.items (): + for k, v in new_stats.items(): if k in increased_classes: - self.assertEqual (old_stats[k]+1, new_stats[k]) + self.assertEqual(old_stats[k] + 1, new_stats[k]) else: - self.assertEqual (old_stats [k], new_stats [k], - "Class %s should have the same instances" % k) + self.assertEqual(old_stats[k], new_stats[k], + "Class %s should have the same instances" % k) + def test_stats_02_insert_deep_class(self): + self.clean_up_instances.append("test://stats-02") + old_stats = self.__get_stats() + self.tracker.update("INSERT { <test://stats-02> a nmm:Photo. }") + new_stats = self.__get_stats() - def test_stats_02_insert_deep_class (self): - self.clean_up_instances.append ("test://stats-02") - old_stats = self.__get_stats () - self.tracker.update ("INSERT { <test://stats-02> a nmm:Photo. }") - new_stats = self.__get_stats () - - increased_classes = [ NIE_IE, RDFS_RESOURCE] + increased_classes = [NIE_IE, RDFS_RESOURCE] new_classes = ["nmm:Photo", "nfo:Visual", "nfo:Image", "nfo:Media"] # There were no instances of those classes before, check they are now for c in new_classes: - self.assertIn (c, new_stats) - - for k, v in new_stats.items (): + self.assertIn(c, new_stats) + + for k, v in new_stats.items(): if k in increased_classes: - self.assertEqual (old_stats [k]+1, new_stats[k]) + self.assertEqual(old_stats[k] + 1, new_stats[k]) elif k in new_classes: # This classes could exists previous or not! if k in old_stats: - self.assertEqual (old_stats [k]+1, new_stats [k]) + self.assertEqual(old_stats[k] + 1, new_stats[k]) else: - self.assertEqual (new_stats [k], 1) + self.assertEqual(new_stats[k], 1) else: - self.assertEqual (old_stats [k], new_stats[k]) + self.assertEqual(old_stats[k], new_stats[k]) - def test_stats_03_delete_deep_class (self): - self.clean_up_instances.append ("test://stats-03") - self.tracker.update ("INSERT { <test://stats-03> a nmm:Photo. }") + def test_stats_03_delete_deep_class(self): + self.clean_up_instances.append("test://stats-03") + self.tracker.update("INSERT { <test://stats-03> a nmm:Photo. }") - old_stats = self.__get_stats () - self.tracker.update ("DELETE { <test://stats-03> a rdfs:Resource. }") - new_stats = self.__get_stats () + old_stats = self.__get_stats() + self.tracker.update("DELETE { <test://stats-03> a rdfs:Resource. }") + new_stats = self.__get_stats() decreased_classes = [NIE_IE, RDFS_RESOURCE] # These classes could have no instance - no_instances_classes = ["nmm:Photo", "nfo:Visual", "nfo:Image", "nfo:Media"] + no_instances_classes = ["nmm:Photo", + "nfo:Visual", "nfo:Image", "nfo:Media"] for c in no_instances_classes: if (old_stats[c] == 1): - self.assertNotIn (c, new_stats) + self.assertNotIn(c, new_stats) else: - self.assertEqual (old_stats[c]-1, new_stats[c]) + self.assertEqual(old_stats[c] - 1, new_stats[c]) - for k, v in new_stats.items (): + for k, v in new_stats.items(): if k in decreased_classes: - self.assertEqual (old_stats [k]-1, new_stats[k]) + self.assertEqual(old_stats[k] - 1, new_stats[k]) else: - self.assertEqual (old_stats [k], new_stats [k]) + self.assertEqual(old_stats[k], new_stats[k]) if __name__ == "__main__": - ut.main () - - + ut.main() diff --git a/tests/functional-tests/16-collation.py b/tests/functional-tests/16-collation.py index 76e22f236..36a1fbbc7 100755 --- a/tests/functional-tests/16-collation.py +++ b/tests/functional-tests/16-collation.py @@ -29,31 +29,33 @@ import locale import unittest as ut from common.utils.storetest import CommonTrackerStoreTest as CommonTrackerStoreTest + class TrackerStoreCollationTests (CommonTrackerStoreTest): """ Insert few instances with a text field containing collation-problematic words. Ask for those instances order by the field and check the results. """ - def setUp (self): + + def setUp(self): """ Each test append to this list the used URIS, so they can be removed in the tearDown """ self.clean_up_instances = [] - def tearDown (self): + def tearDown(self): for uri in self.clean_up_instances: - self.tracker.update ("DELETE { <%s> a rdfs:Resource. }" % (uri)) + self.tracker.update("DELETE { <%s> a rdfs:Resource. }" % (uri)) self.clean_up_instances = [] - time.sleep (1) + time.sleep(1) - def __insert_text (self, text): - uri = "test://collation-01-%d" % (random.randint (1, 1000)) + def __insert_text(self, text): + uri = "test://collation-01-%d" % (random.randint(1, 1000)) # There is a remote chance to get a duplicate int while (uri in self.clean_up_instances): - uri = "test://collation-01-%d" % (random.randint (1, 1000)) - self.clean_up_instances.append (uri) - + uri = "test://collation-01-%d" % (random.randint(1, 1000)) + self.clean_up_instances.append(uri) + self.tracker.update (""" INSERT { <%s> a nie:InformationElement ; @@ -62,7 +64,7 @@ class TrackerStoreCollationTests (CommonTrackerStoreTest): } """ % (uri, text)) - def get_text_sorted_by_collation (self): + def get_text_sorted_by_collation(self): return self.tracker.query (""" SELECT ?title WHERE { ?u a nie:InformationElement ; @@ -71,57 +73,57 @@ class TrackerStoreCollationTests (CommonTrackerStoreTest): } ORDER BY ?title """) - def __collation_test (self, input_list, expected_list): + def __collation_test(self, input_list, expected_list): for i in input_list: - self.__insert_text (i) + self.__insert_text(i) - results = [r[0] for r in self.get_text_sorted_by_collation ()] - self.assertEqual (len (results), len (expected_list)) + results = [r[0] for r in self.get_text_sorted_by_collation()] + self.assertEqual(len(results), len(expected_list)) - for r in range (0, len (results)): - self.assertEqual (results[r], expected_list [r], - """Error: + for r in range(0, len(results)): + self.assertEqual(results[r], expected_list[r], + """Error: Expected : *** %s Result : *** %s Using locale (%s, %s) """ % (expected_list, results, - locale.getdefaultlocale ()[0], - locale.getdefaultlocale ()[1])) + locale.getdefaultlocale()[0], + locale.getdefaultlocale()[1])) - def test_collation_01 (self): + def test_collation_01(self): """ Behaves as case-insensitive """ input_dt = ["abb", "bb", "Abc", "Ba"] expected = ["abb", "Abc", "Ba", "bb"] - self.__collation_test (input_dt, expected) + self.__collation_test(input_dt, expected) - def test_collation_02 (self): + def test_collation_02(self): """ In conflict, Capital letters go *after* small letters """ input_dt = ["Bb", "bb", "aa", "Aa"] expected = ["aa", "Aa", "bb", "Bb"] - self.__collation_test (input_dt, expected) + self.__collation_test(input_dt, expected) - def test_collation_03 (self): + def test_collation_03(self): """ Example from the unicode spec http://www.unicode.org/reports/tr10/#Main_Algorithm """ input_dt = ["Cab", "cab", "dab", "cáb"] expected = ["cab", "Cab", "cáb", "dab"] - self.__collation_test (input_dt, expected) + self.__collation_test(input_dt, expected) - def test_collation_04 (self): + def test_collation_04(self): """ Spanish test in english locale """ input_dt = ["ä", "ö", "a", "e", "i", "o", "u"] expected = ["a", "ä", "e", "i", "o", "ö", "u"] - self.__collation_test (input_dt, expected) + self.__collation_test(input_dt, expected) if __name__ == "__main__": print(""" @@ -129,6 +131,4 @@ if __name__ == "__main__": * Check what happens in non-english encoding * Dynamic change of collation (not implemented yet in tracker) """) - ut.main () - - + ut.main() diff --git a/tests/functional-tests/17-ontology-changes.py b/tests/functional-tests/17-ontology-changes.py index 3c5ff29c6..687757fe1 100755 --- a/tests/functional-tests/17-ontology-changes.py +++ b/tests/functional-tests/17-ontology-changes.py @@ -38,7 +38,6 @@ from common.utils.expectedFailure import expectedFailureJournal import unittest as ut - RDFS_RANGE = "http://www.w3.org/2000/01/rdf-schema#range" XSD_DATETIME = "http://www.w3.org/2001/XMLSchema#dateTime" XSD_STRING = "http://www.w3.org/2001/XMLSchema#string" @@ -46,7 +45,7 @@ XSD_INTEGER = "http://www.w3.org/2001/XMLSchema#integer" TEST_PREFIX = "http://example.org/ns#" -TEST_ENV_VARS = { "LC_COLLATE": "en_GB.utf8" } +TEST_ENV_VARS = {"LC_COLLATE": "en_GB.utf8"} REASONABLE_TIMEOUT = 5 @@ -56,6 +55,7 @@ class UnableToBootException (Exception): class TrackerSystemAbstraction (object): + def __init__(self, settings=None): self.store = None self._dirs = {} @@ -66,7 +66,7 @@ class TrackerSystemAbstraction (object): def xdg_cache_home(self): return os.path.join(self._basedir, 'cache') - def set_up_environment (self, settings=None, ontodir=None): + def set_up_environment(self, settings=None, ontodir=None): """ Sets up the XDG_*_HOME variables and make sure the directories exist @@ -78,22 +78,23 @@ class TrackerSystemAbstraction (object): self._basedir = tempfile.mkdtemp() self._dirs = { - "XDG_DATA_HOME" : self.xdg_data_home(), + "XDG_DATA_HOME": self.xdg_data_home(), "XDG_CACHE_HOME": self.xdg_cache_home() } for var, directory in list(self._dirs.items()): - os.makedirs (directory) - os.makedirs (os.path.join(directory, 'tracker')) - os.environ [var] = directory + os.makedirs(directory) + os.makedirs(os.path.join(directory, 'tracker')) + os.environ[var] = directory if ontodir: - helpers.log ("export %s=%s" % ("TRACKER_DB_ONTOLOGIES_DIR", ontodir)) - os.environ ["TRACKER_DB_ONTOLOGIES_DIR"] = ontodir + helpers.log("export %s=%s" % + ("TRACKER_DB_ONTOLOGIES_DIR", ontodir)) + os.environ["TRACKER_DB_ONTOLOGIES_DIR"] = ontodir - for var, value in TEST_ENV_VARS.items (): - helpers.log ("export %s=%s" %(var, value)) - os.environ [var] = value + for var, value in TEST_ENV_VARS.items(): + helpers.log("export %s=%s" % (var, value)) + os.environ[var] = value # Previous loop should have set DCONF_PROFILE to the test location if settings is not None: @@ -106,32 +107,33 @@ class TrackerSystemAbstraction (object): for key, value in contents.items(): dconf.write(key, value) - def tracker_store_testing_start (self, confdir=None, ontodir=None): + def tracker_store_testing_start(self, confdir=None, ontodir=None): """ Stops any previous instance of the store, calls set_up_environment, and starts a new instances of the store """ - self.set_up_environment (confdir, ontodir) + self.set_up_environment(confdir, ontodir) - self.store = helpers.StoreHelper () - self.store.start () + self.store = helpers.StoreHelper() + self.store.start() - def tracker_store_restart_with_new_ontologies (self, ontodir): - self.store.stop () + def tracker_store_restart_with_new_ontologies(self, ontodir): + self.store.stop() if ontodir: - os.environ ["TRACKER_DB_ONTOLOGIES_DIR"] = ontodir + os.environ["TRACKER_DB_ONTOLOGIES_DIR"] = ontodir try: - self.store.start () + self.store.start() except GLib.Error: - raise UnableToBootException ("Unable to boot the store \n(" + str(e) + ")") + raise UnableToBootException( + "Unable to boot the store \n(" + str(e) + ")") - def finish (self): + def finish(self): """ Stop all running processes and remove all test data. """ if self.store: - self.store.stop () + self.store.stop() for path in list(self._dirs.values()): shutil.rmtree(path) @@ -142,73 +144,71 @@ class OntologyChangeTestTemplate (ut.TestCase): """ Template class for the ontology changes tests. The tests are subclasses of this, implementing these methods: - + * set_ontology_dirs * insert_data * validate_status - + and adding a method 'test_x_y_z' to be invoked by unittest. - + Check doc in those methods for the specific details. """ - - def get_ontology_dir (self, param): + + def get_ontology_dir(self, param): return os.path.join(cfg.TEST_ONTOLOGIES_DIR, param) - def setUp (self): - self.system = TrackerSystemAbstraction () + def setUp(self): + self.system = TrackerSystemAbstraction() - def tearDown (self): + def tearDown(self): self.system.finish() - def template_test_ontology_change (self): - - self.set_ontology_dirs () + def template_test_ontology_change(self): - - basic_ontologies = self.get_ontology_dir (self.FIRST_ONTOLOGY_DIR) - modified_ontologies = self.get_ontology_dir (self.SECOND_ONTOLOGY_DIR) + self.set_ontology_dirs() - self.__assert_ontology_dates (basic_ontologies, modified_ontologies) + basic_ontologies = self.get_ontology_dir(self.FIRST_ONTOLOGY_DIR) + modified_ontologies = self.get_ontology_dir(self.SECOND_ONTOLOGY_DIR) + self.__assert_ontology_dates(basic_ontologies, modified_ontologies) - self.system.tracker_store_testing_start (ontodir=basic_ontologies) + self.system.tracker_store_testing_start(ontodir=basic_ontologies) self.tracker = self.system.store - self.insert_data () + self.insert_data() try: # Boot the second set of ontologies - self.system.tracker_store_restart_with_new_ontologies (modified_ontologies) + self.system.tracker_store_restart_with_new_ontologies( + modified_ontologies) except UnableToBootException as e: - self.fail (str(self.__class__) + " " + str(e)) + self.fail(str(self.__class__) + " " + str(e)) - self.validate_status () + self.validate_status() - def set_ontology_dirs (self): + def set_ontology_dirs(self): """ Implement this method in the subclass setting values for: self.FIRST_ONTOLOGY_DIR and self.SECOND_ONTOLOGY_DIR """ - raise Exception ("Subclasses must implement 'set_ontology_dir'") + raise Exception("Subclasses must implement 'set_ontology_dir'") - def insert_data (self): + def insert_data(self): """ Put in the store some data with the FIRST ontology """ - raise Exception ("Subclasses must implement 'insert_data'") + raise Exception("Subclasses must implement 'insert_data'") - def validate_status (self): + def validate_status(self): """ This is called after restarting the store with the SECOND ontology Check that the inserted data was handled correctly and the ontology is up to date """ - raise Exception ("Subclasses must implement 'validate_status'") + raise Exception("Subclasses must implement 'validate_status'") - - def assertInDbusResult (self, member, dbus_result, column=0): + def assertInDbusResult(self, member, dbus_result, column=0): """ Convenience assertion used in these tests """ @@ -216,42 +216,47 @@ class OntologyChangeTestTemplate (ut.TestCase): if member == row[column]: return # This is going to fail with pretty printing - self.assertIn (member, dbus_result) + self.assertIn(member, dbus_result) - def assertNotInDbusResult (self, member, dbus_result, column=0): + def assertNotInDbusResult(self, member, dbus_result, column=0): """ Convenience assertion used in these tests """ for row in dbus_result: if member == str(row[column]): # This is going to fail with pretty printing - self.fail ("'%s' wasn't supposed to be in '%s'" % (member, dbus_result)) + self.fail("'%s' wasn't supposed to be in '%s'" % + (member, dbus_result)) return - def __assert_ontology_dates (self, first_dir, second_dir): + def __assert_ontology_dates(self, first_dir, second_dir): """ Asserts that 91-test.ontology in second_dir has a more recent modification time than in first_dir """ ISO9601_REGEX = "(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)" - def get_ontology_date (ontology): - for line in open (ontology, 'r'): + def get_ontology_date(ontology): + for line in open(ontology, 'r'): if "nao:lastModified" in line: - getmodtime = re.compile ('nao:lastModified\ \"' + ISO9601_REGEX + '\"') - modtime_match = getmodtime.search (line) + getmodtime = re.compile( + 'nao:lastModified\ \"' + ISO9601_REGEX + '\"') + modtime_match = getmodtime.search(line) if (modtime_match): - nao_date = modtime_match.group (1) - return time.strptime(nao_date, "%Y-%m-%dT%H:%M:%SZ") + nao_date = modtime_match.group(1) + return time.strptime(nao_date, "%Y-%m-%dT%H:%M:%SZ") else: print("something funky in", line) break - first_date = get_ontology_date (os.path.join (first_dir, "91-test.ontology")) - second_date = get_ontology_date (os.path.join (second_dir, "91-test.ontology")) + first_date = get_ontology_date( + os.path.join(first_dir, "91-test.ontology")) + second_date = get_ontology_date( + os.path.join(second_dir, "91-test.ontology")) if first_date >= second_date: - self.fail ("nao:modifiedTime in '%s' is not more recent in the second ontology" % ("91-test.ontology")) + self.fail("nao:modifiedTime in '%s' is not more recent in the second ontology" % ( + "91-test.ontology")) class PropertyRangeStringToDate (OntologyChangeTestTemplate): @@ -261,26 +266,28 @@ class PropertyRangeStringToDate (OntologyChangeTestTemplate): @ut.skip("Fails with: basic-future/91-test.ontology: Unsupported ontology change for http://example.org/ns#a_string: can't change rdfs:range (old=http://www.w3.org/2001/XMLSchema#dateTime, attempted new=http://www.w3.org/2001/XMLSchema#string)") @expectedFailureJournal() - def test_property_range_string_to_date (self): - self.template_test_ontology_change () + def test_property_range_string_to_date(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "property-range-string-to-date" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/property-range/string-to-date" - self.tracker.update ("INSERT { <%s> a test:A ; test:a_string '2010-10-12T13:30:00Z' }" + self.tracker.update("INSERT { <%s> a test:A ; test:a_string '2010-10-12T13:30:00Z' }" % (self.instance)) - def validate_status (self): + def validate_status(self): # Query the ontology itself - result = self.tracker.query ("SELECT ?o WHERE { test:a_string rdfs:range ?o }") - self.assertEqual (result[0][0], XSD_DATETIME) + result = self.tracker.query( + "SELECT ?o WHERE { test:a_string rdfs:range ?o }") + self.assertEqual(result[0][0], XSD_DATETIME) # Check the value is there - result = self.tracker.query ("SELECT ?o WHERE { <%s> test:a_string ?o . }" % (self.instance)) - self.assertEqual (result[0][0], "2010-10-12T13:30:00Z") + result = self.tracker.query( + "SELECT ?o WHERE { <%s> test:a_string ?o . }" % (self.instance)) + self.assertEqual(result[0][0], "2010-10-12T13:30:00Z") class PropertyRangeDateToString (OntologyChangeTestTemplate): @@ -290,50 +297,57 @@ class PropertyRangeDateToString (OntologyChangeTestTemplate): @expectedFailureJournal() @ut.skip("fails with: basic-future/91-test.ontology: Unsupported ontology change for http://example.org/ns#a_string: can't change rdfs:range (old=http://www.w3.org/2001/XMLSchema#dateTime, attempted new=http://www.w3.org/2001/XMLSchema#string)") - def test_property_range_date_to_string (self): - self.template_test_ontology_change () + def test_property_range_date_to_string(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "property-range-string-to-date" self.SECOND_ONTOLOGY_DIR = "basic-future" - - def insert_data (self): + + def insert_data(self): self.instance = "test://ontology-change/property-range/date-to-string" - self.tracker.update ("INSERT { <%s> a test:A ; test:a_string '2010-10-12T13:30:00Z' }" + self.tracker.update("INSERT { <%s> a test:A ; test:a_string '2010-10-12T13:30:00Z' }" % (self.instance)) - def validate_status (self): + def validate_status(self): # Query the ontology itself - result = self.tracker.query ("SELECT ?o WHERE { test:a_string rdfs:range ?o }") - self.assertEqual (result[0][0], XSD_STRING) + result = self.tracker.query( + "SELECT ?o WHERE { test:a_string rdfs:range ?o }") + self.assertEqual(result[0][0], XSD_STRING) # Check the value is there - result = self.tracker.query ("SELECT ?o WHERE { <%s> test:a_string ?o . }" % (self.instance)) - self.assertEqual (result[0][0], "2010-10-12T13:30:00Z") + result = self.tracker.query( + "SELECT ?o WHERE { <%s> test:a_string ?o . }" % (self.instance)) + self.assertEqual(result[0][0], "2010-10-12T13:30:00Z") + class PropertyRangeIntToString (OntologyChangeTestTemplate): """ Change the range of a property from int to string. There shouldn't be any data loss. """ @ut.skip("Fails with: Unable to insert multiple values for subject `http://example.org/ns#a_int' and single valued property `rdfs:comment' (old_value: 'This property is integer in basic here is string', new value: 'Property to test the changes string/int')") - def test_property_range_int_to_str (self): - self.template_test_ontology_change () + def test_property_range_int_to_str(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "property-range-int-to-string" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/property-range/int-to-string" - self.tracker.update ("INSERT { <%s> a test:A; test:a_int 12. }" % (self.instance)) + self.tracker.update( + "INSERT { <%s> a test:A; test:a_int 12. }" % (self.instance)) - def validate_status (self): - result = self.tracker.query ("SELECT ?o WHERE { test:a_int rdfs:range ?o. }") - self.assertEqual (str(result[0][0]), XSD_STRING) + def validate_status(self): + result = self.tracker.query( + "SELECT ?o WHERE { test:a_int rdfs:range ?o. }") + self.assertEqual(str(result[0][0]), XSD_STRING) # Check the value is there - result = self.tracker.query ("SELECT ?o WHERE { <%s> test:a_int ?o .}" % (self.instance)) - self.assertEqual (result[0][0], "12") + result = self.tracker.query( + "SELECT ?o WHERE { <%s> test:a_int ?o .}" % (self.instance)) + self.assertEqual(result[0][0], "12") + class PropertyRangeStringToInt (OntologyChangeTestTemplate): """ @@ -341,56 +355,64 @@ class PropertyRangeStringToInt (OntologyChangeTestTemplate): """ @ut.skip("Fails with: Unable to insert multiple values for subject `http://example.org/ns#a_int' and single valued property `rdfs:comment' (old_value: 'Property to test the changes string/int', new value: 'This property is integer in basic here is string')") - def test_property_range_str_to_int (self): - self.template_test_ontology_change () + def test_property_range_str_to_int(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "property-range-int-to-string" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/property-range/string-to-int" - self.tracker.update ("INSERT { <%s> a test:A; test:a_int '12'. }" % (self.instance)) + self.tracker.update( + "INSERT { <%s> a test:A; test:a_int '12'. }" % (self.instance)) - def validate_status (self): - result = self.tracker.query ("SELECT ?o WHERE { test:a_int rdfs:range ?o. }") - self.assertEqual (str(result[0][0]), XSD_INTEGER) + def validate_status(self): + result = self.tracker.query( + "SELECT ?o WHERE { test:a_int rdfs:range ?o. }") + self.assertEqual(str(result[0][0]), XSD_INTEGER) # Check the value is there - result = self.tracker.query ("SELECT ?o WHERE { <%s> test:a_int ?o .}" % (self.instance)) - self.assertEqual (result[0][0], "12") - + result = self.tracker.query( + "SELECT ?o WHERE { <%s> test:a_int ?o .}" % (self.instance)) + self.assertEqual(result[0][0], "12") + + class PropertyMaxCardinality1toN (OntologyChangeTestTemplate): """ Change cardinality of a property from 1 to N. There shouldn't be any data loss """ @expectedFailureJournal() - def test_property_cardinality_1_to_n (self): - self.template_test_ontology_change () + def test_property_cardinality_1_to_n(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): #self.FIRST_ONTOLOGY_DIR = "basic" #self.SECOND_ONTOLOGY_DIR = "cardinality" self.FIRST_ONTOLOGY_DIR = "cardinality" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/cardinality/1-to-n" - self.tracker.update ("INSERT { <%s> a test:A; test:a_n_cardinality 'some text'. }" % (self.instance)) + self.tracker.update( + "INSERT { <%s> a test:A; test:a_n_cardinality 'some text'. }" % (self.instance)) + + result = self.tracker.query( + "SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") + self.assertEqual(int(result[0][0]), 1) - result = self.tracker.query ("SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") - self.assertEqual (int (result[0][0]), 1) + def validate_status(self): + result = self.tracker.query( + "SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") + self.assertEqual(len(result), 0, "Cardinality should be 0") - - def validate_status (self): - result = self.tracker.query ("SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") - self.assertEqual (len (result), 0, "Cardinality should be 0") - # Check the value is there - result = self.tracker.query ("SELECT ?o WHERE { <%s> test:a_n_cardinality ?o .}" % (self.instance)) - self.assertEqual (str(result[0][0]), "some text") + result = self.tracker.query( + "SELECT ?o WHERE { <%s> test:a_n_cardinality ?o .}" % (self.instance)) + self.assertEqual(str(result[0][0]), "some text") + class PropertyMaxCardinalityNto1 (OntologyChangeTestTemplate): """ @@ -400,78 +422,87 @@ class PropertyMaxCardinalityNto1 (OntologyChangeTestTemplate): """ @ut.expectedFailure - def test_property_cardinality_n_to_1 (self): - self.template_test_ontology_change () + def test_property_cardinality_n_to_1(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "cardinality" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/cardinality/1-to-n" - self.tracker.update ("INSERT { <%s> a test:A; test:a_n_cardinality 'some text'. }" % (self.instance)) + self.tracker.update( + "INSERT { <%s> a test:A; test:a_n_cardinality 'some text'. }" % (self.instance)) + + result = self.tracker.query( + "SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") + self.assertEqual(len(result), 0, "Cardinality should be 0") - result = self.tracker.query ("SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") - self.assertEqual (len (result), 0, "Cardinality should be 0") + def validate_status(self): + result = self.tracker.query( + "SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") + self.assertEqual(int(result[0][0]), 1, "Cardinality should be 1") - - def validate_status (self): - result = self.tracker.query ("SELECT ?o WHERE { test:a_n_cardinality nrl:maxCardinality ?o}") - self.assertEqual (int (result[0][0]), 1, "Cardinality should be 1") - # Check the value is there - result = self.tracker.query ("SELECT ?o WHERE { <%s> test:a_n_cardinality ?o .}" % (self.instance)) - self.assertEqual (str(result[0][0]), "some text") + result = self.tracker.query( + "SELECT ?o WHERE { <%s> test:a_n_cardinality ?o .}" % (self.instance)) + self.assertEqual(str(result[0][0]), "some text") + class ClassNotifySet (OntologyChangeTestTemplate): """ Set tracker:notify to true in a class and check there is no data loss """ - def test_property_notify_set (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_property_notify_set(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "notify" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/notify/true" - self.tracker.update ("INSERT { <%s> a test:A; test:a_string 'some text'. }" % (self.instance)) + self.tracker.update( + "INSERT { <%s> a test:A; test:a_string 'some text'. }" % (self.instance)) + def validate_status(self): + result = self.tracker.query( + "SELECT ?notify WHERE { test:A tracker:notify ?notify}") + self.assertEqual(str(result[0][0]), "true") + + result = self.tracker.query("SELECT ?u WHERE { ?u a test:A. }") + self.assertEqual(str(result[0][0]), self.instance) - def validate_status (self): - result = self.tracker.query ("SELECT ?notify WHERE { test:A tracker:notify ?notify}") - self.assertEqual (str(result[0][0]), "true") - - result = self.tracker.query ("SELECT ?u WHERE { ?u a test:A. }") - self.assertEqual (str(result[0][0]), self.instance) class ClassNotifyUnset (OntologyChangeTestTemplate): """ Set tracker:notify to true in a class and check there is no data loss """ - def test_property_notify_set (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_property_notify_set(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "notify" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): self.instance = "test://ontology-change/notify/true" - self.tracker.update ("INSERT { <%s> a test:A; test:a_string 'some text'. }" % (self.instance)) - + self.tracker.update( + "INSERT { <%s> a test:A; test:a_string 'some text'. }" % (self.instance)) - def validate_status (self): - result = self.tracker.query ("SELECT ?notify WHERE { test:A tracker:notify ?notify}") - if (len (result) == 1): + def validate_status(self): + result = self.tracker.query( + "SELECT ?notify WHERE { test:A tracker:notify ?notify}") + if (len(result) == 1): # Usually is (none) but it was "true" before so now has value. - self.assertEqual (result[0][0], "false") + self.assertEqual(result[0][0], "false") else: - self.assertEqual (len (result), 0) - - result = self.tracker.query ("SELECT ?u WHERE { ?u a test:A. }") - self.assertEqual (str(result[0][0]), self.instance) + self.assertEqual(len(result), 0) + + result = self.tracker.query("SELECT ?u WHERE { ?u a test:A. }") + self.assertEqual(str(result[0][0]), self.instance) class PropertyIndexedSet (OntologyChangeTestTemplate): @@ -479,179 +510,192 @@ class PropertyIndexedSet (OntologyChangeTestTemplate): Set tracker:indexed true to single and multiple valued properties. Check that instances and content of the property are still in the DB """ - def test_indexed_set (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_indexed_set(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "indexed" - def insert_data (self): + def insert_data(self): # Instance with value in the single valued property self.instance_single_valued = "test://ontology-change/indexed/single/true" - self.tracker.update ("INSERT { <%s> a test:A ; test:a_string 'anything 1'. }" + self.tracker.update("INSERT { <%s> a test:A ; test:a_string 'anything 1'. }" % (self.instance_single_valued)) # Instance with value in the n valued property self.instance_n_valued = "test://ontology-change/indexed/multiple/true" - self.tracker.update ("INSERT { <%s> a test:A ; test:a_n_cardinality 'anything n'. }" + self.tracker.update("INSERT { <%s> a test:A ; test:a_n_cardinality 'anything n'. }" % (self.instance_n_valued)) - def validate_status (self): + def validate_status(self): # Check ontology and instance for the single valued property - result = self.tracker.query ("SELECT ?indexed WHERE { test:a_string tracker:indexed ?indexed}") - self.assertEqual (str(result[0][0]), "true") + result = self.tracker.query( + "SELECT ?indexed WHERE { test:a_string tracker:indexed ?indexed}") + self.assertEqual(str(result[0][0]), "true") - result = self.tracker.query ("SELECT ?content WHERE { <%s> a test:A; test:a_string ?content. }" + result = self.tracker.query("SELECT ?content WHERE { <%s> a test:A; test:a_string ?content. }" % (self.instance_single_valued)) - self.assertEqual (str(result[0][0]), "anything 1") + self.assertEqual(str(result[0][0]), "anything 1") # Check ontology and instance for the multiple valued property - result = self.tracker.query ("SELECT ?indexed WHERE { test:a_n_cardinality tracker:indexed ?indexed}") - self.assertEqual (str(result[0][0]), "true") + result = self.tracker.query( + "SELECT ?indexed WHERE { test:a_n_cardinality tracker:indexed ?indexed}") + self.assertEqual(str(result[0][0]), "true") - result = self.tracker.query ("SELECT ?content WHERE { <%s> a test:A; test:a_n_cardinality ?content. }" + result = self.tracker.query("SELECT ?content WHERE { <%s> a test:A; test:a_n_cardinality ?content. }" % (self.instance_n_valued)) - self.assertEqual (str(result[0][0]), "anything n") + self.assertEqual(str(result[0][0]), "anything n") + class PropertyIndexedUnset (OntologyChangeTestTemplate): """ tracker:indexed property from true to false in single and multiple valued properties. Check that instances and content of the property are still in the DB. """ - def test_indexed_unset (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_indexed_unset(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "indexed" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): # Instance with value in the single valued property self.instance_single_valued = "test://ontology-change/indexed/single/true" - self.tracker.update ("INSERT { <%s> a test:A ; test:a_string 'anything 1'. }" + self.tracker.update("INSERT { <%s> a test:A ; test:a_string 'anything 1'. }" % (self.instance_single_valued)) # Instance with value in the n valued property self.instance_n_valued = "test://ontology-change/indexed/multiple/true" - self.tracker.update ("INSERT { <%s> a test:A ; test:a_n_cardinality 'anything n'. }" + self.tracker.update("INSERT { <%s> a test:A ; test:a_n_cardinality 'anything n'. }" % (self.instance_n_valued)) - def validate_status (self): + def validate_status(self): # # NOTE: tracker:indexed can be 'false' or None. In both cases is fine. - # - + # + # Check ontology and instance for the single valued property - result = self.tracker.query ("SELECT ?indexed WHERE { test:a_string tracker:indexed ?indexed}") - self.assertEqual (str(result[0][0]), "false") + result = self.tracker.query( + "SELECT ?indexed WHERE { test:a_string tracker:indexed ?indexed}") + self.assertEqual(str(result[0][0]), "false") - result = self.tracker.query ("SELECT ?content WHERE { <%s> a test:A; test:a_string ?content. }" + result = self.tracker.query("SELECT ?content WHERE { <%s> a test:A; test:a_string ?content. }" % (self.instance_single_valued)) - self.assertEqual (str(result[0][0]), "anything 1") + self.assertEqual(str(result[0][0]), "anything 1") # Check ontology and instance for the multiple valued property - result = self.tracker.query ("SELECT ?indexed WHERE { test:a_n_cardinality tracker:indexed ?indexed}") - self.assertEqual (str(result[0][0]), "false") + result = self.tracker.query( + "SELECT ?indexed WHERE { test:a_n_cardinality tracker:indexed ?indexed}") + self.assertEqual(str(result[0][0]), "false") - result = self.tracker.query ("SELECT ?content WHERE { <%s> a test:A; test:a_n_cardinality ?content. }" + result = self.tracker.query("SELECT ?content WHERE { <%s> a test:A; test:a_n_cardinality ?content. }" % (self.instance_n_valued)) - self.assertEqual (str(result[0][0]), "anything n") + self.assertEqual(str(result[0][0]), "anything n") + class OntologyAddClassTest (OntologyChangeTestTemplate): """ Add a class in the ontology. """ - def test_ontology_add_class (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_ontology_add_class(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "add-class" - def insert_data (self): + def insert_data(self): # No need, adding a class pass - def validate_status (self): + def validate_status(self): # check the class is there - result = self.tracker.query ("SELECT ?k WHERE { ?k a rdfs:Class. }") - self.assertInDbusResult (TEST_PREFIX + "D", result) + result = self.tracker.query("SELECT ?k WHERE { ?k a rdfs:Class. }") + self.assertInDbusResult(TEST_PREFIX + "D", result) - result = self.tracker.query ("SELECT ?k WHERE { ?k a rdfs:Class. }") - self.assertInDbusResult (TEST_PREFIX + "E", result) + result = self.tracker.query("SELECT ?k WHERE { ?k a rdfs:Class. }") + self.assertInDbusResult(TEST_PREFIX + "E", result) class OntologyRemoveClassTest (OntologyChangeTestTemplate): """ Remove a class from the ontology. With and without superclasses. """ - def test_ontology_remove_class (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_ontology_remove_class(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "add-class" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): self.instance_e = "test://ontology-change/removal/class/1" - self.tracker.update ("INSERT { <%s> a test:E. }" % self.instance_e) + self.tracker.update("INSERT { <%s> a test:E. }" % self.instance_e) self.instance_d = "test://ontology-change/removal/class/2" - self.tracker.update ("INSERT { <%s> a test:D. }" % self.instance_d) + self.tracker.update("INSERT { <%s> a test:D. }" % self.instance_d) - def validate_status (self): + def validate_status(self): # # The classes are not actually removed... so this assertions are not valid (yet?) # - + #result = self.tracker.query ("SELECT ?k WHERE { ?k a rdfs:Class. }") #self.assertNotInDbusResult (TEST_PREFIX + "E", result) #self.assertNotInDbusResult (TEST_PREFIX + "D", result) # D is a subclass of A, removing D should keep the A instances - result = self.tracker.query ("SELECT ?i WHERE { ?i a test:A. }") - self.assertEqual (result[0][0], self.instance_e) + result = self.tracker.query("SELECT ?i WHERE { ?i a test:A. }") + self.assertEqual(result[0][0], self.instance_e) + class OntologyAddPropertyTest (OntologyChangeTestTemplate): """ Add new properties in the ontology, with/without super prop and different ranges and cardinalities """ @ut.skip("Fails with:Unable to insert multiple values for subject `http://example.org/ns#a_int' and single valued property `rdfs:comment' (old_value: 'This property is integer in basic here is string', new value: 'Property to test the changes string/int')") - def test_ontology_add_property (self): - self.template_test_ontology_change () + def test_ontology_add_property(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "add-prop" - def insert_data (self): + def insert_data(self): # No need, adding new properties pass - def validate_status (self): - result = self.tracker.query ("SELECT ?k WHERE { ?k a rdf:Property}") - self.assertInDbusResult (TEST_PREFIX + "new_prop_int", result) - self.assertInDbusResult (TEST_PREFIX + "new_prop_int_n", result) + def validate_status(self): + result = self.tracker.query("SELECT ?k WHERE { ?k a rdf:Property}") + self.assertInDbusResult(TEST_PREFIX + "new_prop_int", result) + self.assertInDbusResult(TEST_PREFIX + "new_prop_int_n", result) - self.assertInDbusResult (TEST_PREFIX + "new_prop_string", result) - self.assertInDbusResult (TEST_PREFIX + "new_prop_string_n", result) + self.assertInDbusResult(TEST_PREFIX + "new_prop_string", result) + self.assertInDbusResult(TEST_PREFIX + "new_prop_string_n", result) + + self.assertInDbusResult(TEST_PREFIX + "new_subprop_string", result) + self.assertInDbusResult(TEST_PREFIX + "new_subprop_string_n", result) - self.assertInDbusResult (TEST_PREFIX + "new_subprop_string", result) - self.assertInDbusResult (TEST_PREFIX + "new_subprop_string_n", result) class OntologyRemovePropertyTest (OntologyChangeTestTemplate): """ Remove properties from the ontology, with and without super props and different ranges and cardinalities """ - def test_ontology_remove_property (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_ontology_remove_property(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "add-prop" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): self.instance_a = "test://ontology-change/remove/properties/1" self.tracker.update (""" INSERT { <%s> a test:A; @@ -670,14 +714,16 @@ class OntologyRemovePropertyTest (OntologyChangeTestTemplate): test:new_subprop_string_n 'super-prop also keeps this value'. } """ % (self.instance_b)) - self.assertTrue (self.tracker.ask ("ASK { <%s> a test:A}" % (self.instance_a)), "The instance is not there") + self.assertTrue(self.tracker.ask("ASK { <%s> a test:A}" % ( + self.instance_a)), "The instance is not there") - def validate_status (self): + def validate_status(self): # # Note: on removal basically nothing happens. The property and values are still in the DB # - # Maybe we should test there forcing a db reconstruction and journal replay - + # Maybe we should test there forcing a db reconstruction and journal + # replay + # First the ontology ## result = self.tracker.query ("SELECT ?k WHERE { ?k a rdf:Property}") ## self.assertNotInDbusResult (TEST_PREFIX + "new_prop_int", result) @@ -690,28 +736,33 @@ class OntologyRemovePropertyTest (OntologyChangeTestTemplate): ## self.assertNotInDbusResult (TEST_PREFIX + "new_subprop_string_n", result) # The instances are still there - self.assertTrue (self.tracker.ask ("ASK { <%s> a test:A}" % (self.instance_a))) - self.assertTrue (self.tracker.ask ("ASK { <%s> a test:B}" % (self.instance_b))) + self.assertTrue(self.tracker.ask( + "ASK { <%s> a test:A}" % (self.instance_a))) + self.assertTrue(self.tracker.ask( + "ASK { <%s> a test:B}" % (self.instance_b))) + + check = self.tracker.ask( + "ASK { <%s> test:a_superprop 'super-prop keeps this value' }" % (self.instance_b)) + self.assertTrue(check, "This property and value should exist") + + check = self.tracker.ask( + "ASK { <%s> test:a_superprop_n 'super-prop also keeps this value' }" % (self.instance_b)) + self.assertTrue(check, "This property and value should exist") - check = self.tracker.ask ("ASK { <%s> test:a_superprop 'super-prop keeps this value' }" % (self.instance_b)) - self.assertTrue (check, "This property and value should exist") - - check = self.tracker.ask ("ASK { <%s> test:a_superprop_n 'super-prop also keeps this value' }" % (self.instance_b)) - self.assertTrue (check, "This property and value should exist") class DomainIndexAddTest (OntologyChangeTestTemplate): """ Add tracker:domainIndex to a class and check there is no data loss. """ @ut.skip("Fails with: basic-future/91-test.ontology: Unsupported ontology change for test:b_property: can't change rdfs:domain (old=test:A, attempted new=test:B) ") - def test_domain_index_add (self): - self.template_test_ontology_change () + def test_domain_index_add(self): + self.template_test_ontology_change() - def set_ontology_dirs (self): + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "add-domainIndex" - def insert_data (self): + def insert_data(self): self.instance_a = "test://ontology-changes/properties/add-domain-index/a" self.tracker.update (""" INSERT { <%s> a test:B ; @@ -724,34 +775,39 @@ class DomainIndexAddTest (OntologyChangeTestTemplate): test:a_string 'test-value' ; test:a_n_cardinality 'another-test-value'. }""" % (self.instance_b)) - def validate_status (self): + def validate_status(self): # Check the ontology - has_domainIndex = self.tracker.ask ("ASK { test:B tracker:domainIndex test:a_string }") - self.assertTrue (has_domainIndex) + has_domainIndex = self.tracker.ask( + "ASK { test:B tracker:domainIndex test:a_string }") + self.assertTrue(has_domainIndex) - has_domainIndex = self.tracker.ask ("ASK { test:C tracker:domainIndex test:a_n_cardinality }") - self.assertTrue (has_domainIndex) + has_domainIndex = self.tracker.ask( + "ASK { test:C tracker:domainIndex test:a_n_cardinality }") + self.assertTrue(has_domainIndex) # Check the data - dataok = self.tracker.ask ("ASK { <%s> test:a_string 'test-value' }" % (self.instance_a)) - self.assertTrue (dataok) + dataok = self.tracker.ask( + "ASK { <%s> test:a_string 'test-value' }" % (self.instance_a)) + self.assertTrue(dataok) - dataok = self.tracker.ask ("ASK { <%s> test:a_n_cardinality 'another-test-value' }" % (self.instance_b)) - self.assertTrue (dataok) + dataok = self.tracker.ask( + "ASK { <%s> test:a_n_cardinality 'another-test-value' }" % (self.instance_b)) + self.assertTrue(dataok) class DomainIndexRemoveTest (OntologyChangeTestTemplate): """ Remove tracker:domainIndex to a class and check there is no data loss. """ - def test_domain_index_remove (self): - self.template_test_ontology_change () - def set_ontology_dirs (self): + def test_domain_index_remove(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "add-domainIndex" self.SECOND_ONTOLOGY_DIR = "basic-future" - def insert_data (self): + def insert_data(self): self.instance_a = "test://ontology-changes/properties/add-domain-index/a" self.tracker.update (""" INSERT { <%s> a test:B ; @@ -764,20 +820,24 @@ class DomainIndexRemoveTest (OntologyChangeTestTemplate): test:a_string 'test-value' ; test:a_n_cardinality 'another-test-value'. }""" % (self.instance_b)) - def validate_status (self): + def validate_status(self): # Check the ontology - has_domainIndex = self.tracker.ask ("ASK { test:B tracker:domainIndex test:a_string }") - self.assertFalse (has_domainIndex) + has_domainIndex = self.tracker.ask( + "ASK { test:B tracker:domainIndex test:a_string }") + self.assertFalse(has_domainIndex) - has_domainIndex = self.tracker.ask ("ASK { test:C tracker:domainIndex test:a_n_cardinality }") - self.assertFalse (has_domainIndex) + has_domainIndex = self.tracker.ask( + "ASK { test:C tracker:domainIndex test:a_n_cardinality }") + self.assertFalse(has_domainIndex) # Check the data - dataok = self.tracker.ask ("ASK { <%s> test:a_string 'test-value' }" % (self.instance_a)) - self.assertTrue (dataok) + dataok = self.tracker.ask( + "ASK { <%s> test:a_string 'test-value' }" % (self.instance_a)) + self.assertTrue(dataok) - dataok = self.tracker.ask ("ASK { <%s> test:a_n_cardinality 'another-test-value' }" % (self.instance_b)) - self.assertTrue (dataok) + dataok = self.tracker.ask( + "ASK { <%s> test:a_n_cardinality 'another-test-value' }" % (self.instance_b)) + self.assertTrue(dataok) class SuperclassRemovalTest (OntologyChangeTestTemplate): @@ -786,17 +846,17 @@ class SuperclassRemovalTest (OntologyChangeTestTemplate): """ @expectedFailureJournal() @ut.skip("Fails with: Unsupported ontology change for http://example.org/ns#B: can't change rdfs:subClassOf (old=-, attempted new=-)") - def test_superclass_removal (self): - self.template_test_ontology_change () - - def set_ontology_dirs (self): + def test_superclass_removal(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "superclass-remove" - - def insert_data (self): - is_subclass = self.tracker.ask ("ASK {test:B rdfs:subClassOf test:A}") - self.assertTrue (is_subclass) - + + def insert_data(self): + is_subclass = self.tracker.ask("ASK {test:B rdfs:subClassOf test:A}") + self.assertTrue(is_subclass) + self.instance_a = "test://ontology-changes/superclasses/remove-superclass/a" self.tracker.update (""" INSERT { <%s> a test:A . } @@ -807,21 +867,22 @@ class SuperclassRemovalTest (OntologyChangeTestTemplate): INSERT { <%s> a test:B . } """ % (self.instance_b)) - result = self.tracker.count_instances ("test:B") - self.assertEqual (result, 1) + result = self.tracker.count_instances("test:B") + self.assertEqual(result, 1) + + result = self.tracker.count_instances("test:A") + self.assertEqual(result, 2) - result = self.tracker.count_instances ("test:A") - self.assertEqual (result, 2) + def validate_status(self): + is_subclass = self.tracker.ask("ASK {test:B rdfs:subClassOf test:A}") + self.assertFalse(is_subclass) - def validate_status (self): - is_subclass = self.tracker.ask ("ASK {test:B rdfs:subClassOf test:A}") - self.assertFalse (is_subclass) + result = self.tracker.count_instances("test:B") + self.assertEqual(result, 1) - result = self.tracker.count_instances ("test:B") - self.assertEqual (result, 1) + result = self.tracker.count_instances("test:A") + self.assertEqual(result, 1) - result = self.tracker.count_instances ("test:A") - self.assertEqual (result, 1) class SuperclassAdditionTest (OntologyChangeTestTemplate): """ @@ -829,17 +890,17 @@ class SuperclassAdditionTest (OntologyChangeTestTemplate): """ @ut.skip("Fails with: basic-future/91-test.ontology: Unsupported ontology change for test:B: can't change rdfs:subClassOf (old=-, attempted new=test:A)") @expectedFailureJournal() - def test_superclass_addition (self): - self.template_test_ontology_change () - - def set_ontology_dirs (self): + def test_superclass_addition(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "superclass-remove" self.SECOND_ONTOLOGY_DIR = "basic-future" - - def insert_data (self): - is_subclass = self.tracker.ask ("ASK {test:B rdfs:subClassOf test:A}") - self.assertFalse (is_subclass) - + + def insert_data(self): + is_subclass = self.tracker.ask("ASK {test:B rdfs:subClassOf test:A}") + self.assertFalse(is_subclass) + self.instance_a = "test://ontology-changes/superclasses/remove-superclass/a" self.tracker.update (""" INSERT { <%s> a test:A . } @@ -850,22 +911,22 @@ class SuperclassAdditionTest (OntologyChangeTestTemplate): INSERT { <%s> a test:B . } """ % (self.instance_b)) - result = self.tracker.count_instances ("test:B") - self.assertEqual (result, 1) + result = self.tracker.count_instances("test:B") + self.assertEqual(result, 1) + + result = self.tracker.count_instances("test:A") + self.assertEqual(result, 1) - result = self.tracker.count_instances ("test:A") - self.assertEqual (result, 1) - - def validate_status (self): - is_subclass = self.tracker.ask ("ASK {test:B rdfs:subClassOf test:A}") - self.assertTrue (is_subclass) + def validate_status(self): + is_subclass = self.tracker.ask("ASK {test:B rdfs:subClassOf test:A}") + self.assertTrue(is_subclass) - result = self.tracker.count_instances ("test:B") - self.assertEqual (result, 1) + result = self.tracker.count_instances("test:B") + self.assertEqual(result, 1) + + result = self.tracker.count_instances("test:A") + self.assertEqual(result, 2) - result = self.tracker.count_instances ("test:A") - self.assertEqual (result, 2) - class PropertyPromotionTest (OntologyChangeTestTemplate): """ @@ -873,35 +934,36 @@ class PropertyPromotionTest (OntologyChangeTestTemplate): """ @ut.skip("Fails with: basic-future/91-test.ontology: Unsupported ontology change for test:b_property: can't change rdfs:domain (old=test:A, attempted new=test:B)") @expectedFailureJournal() - def test_property_promotion (self): - self.template_test_ontology_change () - - def set_ontology_dirs (self): + def test_property_promotion(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "basic" self.SECOND_ONTOLOGY_DIR = "property-promotion" - - def insert_data (self): + + def insert_data(self): self.instance_b = "test://ontology-change/property/promotion-to-superclass/b" self.tracker.update (""" INSERT { <%s> a test:B; test:b_property 'content-b-test'; test:b_property_n 'b-test-n'. } """ % (self.instance_b)) self.instance_a = "test://ontology-change/property/promotion-to-superclass/a" - self.assertRaises (GLib.Error, - self.tracker.update, - "INSERT { <%s> a test:A; test:b_property 'content-a-test'.}" % (self.instance_a)) - - def validate_status (self): + self.assertRaises(GLib.Error, + self.tracker.update, + "INSERT { <%s> a test:A; test:b_property 'content-a-test'.}" % (self.instance_a)) + + def validate_status(self): # This insertion should work now self.tracker.update (""" INSERT { <%s> a test:A; test:b_property 'content-a-test'.} """ % (self.instance_a)) # No data loss - result = self.tracker.query ("SELECT ?v ?w WHERE { <%s> test:b_property ?v ; test:b_property_n ?w }" + result = self.tracker.query("SELECT ?v ?w WHERE { <%s> test:b_property ?v ; test:b_property_n ?w }" % (self.instance_b)) - self.assertEqual (result [0][0], "content-b-test") - self.assertEqual (result [0][1], "b-test-n") + self.assertEqual(result[0][0], "content-b-test") + self.assertEqual(result[0][1], "b-test-n") + class PropertyRelegationTest (OntologyChangeTestTemplate): """ @@ -909,14 +971,14 @@ class PropertyRelegationTest (OntologyChangeTestTemplate): """ @ut.skip("Fails") @expectedFailureJournal() - def test_property_relegation (self): - self.template_test_ontology_change () - - def set_ontology_dirs (self): + def test_property_relegation(self): + self.template_test_ontology_change() + + def set_ontology_dirs(self): self.FIRST_ONTOLOGY_DIR = "property-promotion" self.SECOND_ONTOLOGY_DIR = "basic-future" - - def insert_data (self): + + def insert_data(self): self.instance_b = "test://ontology-change/property/promotion-to-superclass/b" self.tracker.update (""" INSERT { <%s> a test:B; test:b_property 'content-b-test'; test:b_property_n 'b-test-n'. } @@ -926,21 +988,18 @@ class PropertyRelegationTest (OntologyChangeTestTemplate): self.tracker.update (""" INSERT { <%s> a test:A; test:b_property 'content-a-test'.} """ % (self.instance_a)) - - def validate_status (self): + + def validate_status(self): # This insertion should fail now - self.assertRaises (GLib.Error, - self.tracker.update, - "INSERT { <%s> a test:A; test:b_property 'content-a-test'.}" % (self.instance_a)) + self.assertRaises(GLib.Error, + self.tracker.update, + "INSERT { <%s> a test:A; test:b_property 'content-a-test'.}" % (self.instance_a)) # No data loss - result = self.tracker.query ("SELECT ?v ?w WHERE { <%s> test:b_property ?v; test:b_property_n ?w }" + result = self.tracker.query("SELECT ?v ?w WHERE { <%s> test:b_property ?v; test:b_property_n ?w }" % (self.instance_b)) - self.assertEqual (result [0][0], "content-b-test") - self.assertEqual (result [0][1], "b-test-n") - + self.assertEqual(result[0][0], "content-b-test") + self.assertEqual(result[0][1], "b-test-n") if __name__ == "__main__": - ut.main () - - + ut.main() diff --git a/tests/functional-tests/common/utils/configuration.py b/tests/functional-tests/common/utils/configuration.py index 5332e26e7..9fd8c1c64 100644 --- a/tests/functional-tests/common/utils/configuration.py +++ b/tests/functional-tests/common/utils/configuration.py @@ -60,7 +60,9 @@ DCONF_MINER_SCHEMA = "org.freedesktop.Tracker.Miner.Files" # Autoconf substitutes paths in the configuration.json file without # expanding variables, so we need to manually insert these. -def expandvars (variable): + + +def expandvars(variable): # Note: the order matters! result = variable for var, value in [("${datarootdir}", RAW_DATAROOT_DIR), @@ -68,7 +70,7 @@ def expandvars (variable): ("${prefix}", PREFIX), ("@top_srcdir@", TOP_SRCDIR), ("@top_builddir@", TOP_BUILDDIR)]: - result = result.replace (var, value) + result = result.replace(var, value) return result @@ -77,15 +79,18 @@ PREFIX = config['PREFIX'] RAW_EXEC_PREFIX = config['RAW_EXEC_PREFIX'] RAW_DATAROOT_DIR = config['RAW_DATAROOT_DIR'] -TOP_SRCDIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))) +TOP_SRCDIR = os.path.dirname(os.path.dirname( + os.path.dirname(os.path.dirname(os.path.dirname(__file__))))) TOP_BUILDDIR = os.environ['TRACKER_FUNCTIONAL_TEST_BUILD_DIR'] -TEST_ONTOLOGIES_DIR = os.path.normpath(expandvars(config['TEST_ONTOLOGIES_DIR'])) +TEST_ONTOLOGIES_DIR = os.path.normpath( + expandvars(config['TEST_ONTOLOGIES_DIR'])) TRACKER_STORE_PATH = os.path.normpath(expandvars(config['TRACKER_STORE_PATH'])) disableJournal = (len(config['disableJournal']) == 0) + def generated_ttl_dir(): if TOP_BUILDDIR: return os.path.join(TOP_BUILDDIR, 'tests', 'functional-tests', 'ttl') diff --git a/tests/functional-tests/common/utils/dconf.py b/tests/functional-tests/common/utils/dconf.py index 8aa74f29a..d4b42dfe9 100644 --- a/tests/functional-tests/common/utils/dconf.py +++ b/tests/functional-tests/common/utils/dconf.py @@ -5,6 +5,7 @@ import os from common.utils.helpers import log + class DConfClient(object): """ Allow changing Tracker configuration in DConf. @@ -20,7 +21,7 @@ class DConfClient(object): break. """ - def __init__ (self, schema): + def __init__(self, schema): self._settings = Gio.Settings.new(schema) backend = self._settings.get_property('backend') @@ -69,10 +70,10 @@ class DConfClient(object): # XDG_CONFIG_HOME is useless, so we use HOME. This code should not be # needed unless for some reason the test is not being run via the # 'test-runner.sh' script. - dconf_db = os.path.join (os.environ ["HOME"], - ".config", - "dconf", - "trackertest") - if os.path.exists (dconf_db): - log ("[Conf] Removing dconf database: " + dconf_db) - os.remove (dconf_db) + dconf_db = os.path.join(os.environ["HOME"], + ".config", + "dconf", + "trackertest") + if os.path.exists(dconf_db): + log("[Conf] Removing dconf database: " + dconf_db) + os.remove(dconf_db) diff --git a/tests/functional-tests/common/utils/expectedFailure.py b/tests/functional-tests/common/utils/expectedFailure.py index 1b11ec170..e7f0eb68c 100644 --- a/tests/functional-tests/common/utils/expectedFailure.py +++ b/tests/functional-tests/common/utils/expectedFailure.py @@ -1,25 +1,25 @@ #!/usr/bin/python3 -## Code taken and modified from unittest2 framework (case.py) +# Code taken and modified from unittest2 framework (case.py) -## Copyright (c) 1999-2003 Steve Purcell -## Copyright (c) 2003-2010 Python Software Foundation -## Copyright (c) 2010, Nokia (ivan.frade@nokia.com) +# Copyright (c) 1999-2003 Steve Purcell +# Copyright (c) 2003-2010 Python Software Foundation +# Copyright (c) 2010, Nokia (ivan.frade@nokia.com) -## This module is free software, and you may redistribute it and/or modify -## it under the same terms as Python itself, so long as this copyright message -## and disclaimer are retained in their original form. +# This module is free software, and you may redistribute it and/or modify +# it under the same terms as Python itself, so long as this copyright message +# and disclaimer are retained in their original form. -## IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, -## SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF -## THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -## DAMAGE. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, +# SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF +# THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +# DAMAGE. -## THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT -## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -## PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, -## AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE, -## SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. +# THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, +# AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE, +# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. """ Write values in tracker and check the actual values are written @@ -29,11 +29,12 @@ import sys from functools import wraps import common.utils.configuration as cfg + def expectedFailureJournal(): """ Decorator to handle tests that are expected to fail when journal is disabled. """ - def decorator (func): + def decorator(func): # no wrapping if journal is enabled, test is expected to pass if not cfg.disableJournal: return func @@ -44,6 +45,7 @@ def expectedFailureJournal(): func(*args, **kwargs) except Exception: raise ut.case._ExpectedFailure(sys.exc_info()) - raise Exception ("Unexpected success. This should fail because journal is disabled") + raise Exception( + "Unexpected success. This should fail because journal is disabled") return wrapper return decorator diff --git a/tests/functional-tests/common/utils/helpers.py b/tests/functional-tests/common/utils/helpers.py index 8e6a3225c..6e5c26c40 100644 --- a/tests/functional-tests/common/utils/helpers.py +++ b/tests/functional-tests/common/utils/helpers.py @@ -28,14 +28,17 @@ import re from common.utils import configuration as cfg from common.utils import options as options + class NoMetadataException (Exception): pass REASONABLE_TIMEOUT = 30 -def log (message): - if options.is_verbose (): - print (message) + +def log(message): + if options.is_verbose(): + print(message) + class Helper: """ @@ -54,11 +57,11 @@ class Helper: BUS_NAME = None PROCESS_NAME = None - def __init__ (self): + def __init__(self): self.process = None self.available = False - self.loop = GLib.MainLoop () + self.loop = GLib.MainLoop() self.install_glib_excepthook(self.loop) self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, None) @@ -68,51 +71,52 @@ class Helper: Handler to abort test if an exception occurs inside the GLib main loop. """ old_hook = sys.excepthook + def new_hook(etype, evalue, etb): old_hook(etype, evalue, etb) GLib.MainLoop.quit(loop) sys.exit(1) sys.excepthook = new_hook - def _start_process (self, env=None): + def _start_process(self, env=None): path = self.PROCESS_PATH - flags = getattr (self, - "FLAGS", - []) + flags = getattr(self, + "FLAGS", + []) kws = {} - if not options.is_verbose (): - FNULL = open ('/dev/null', 'w') - kws.update({ 'stdout': FNULL, 'stderr': subprocess.PIPE }) + if not options.is_verbose(): + FNULL = open('/dev/null', 'w') + kws.update({'stdout': FNULL, 'stderr': subprocess.PIPE}) if env: kws['env'] = env command = [path] + flags - log ("Starting %s" % ' '.join(command)) + log("Starting %s" % ' '.join(command)) try: - return subprocess.Popen ([path] + flags, **kws) + return subprocess.Popen([path] + flags, **kws) except OSError as e: raise RuntimeError("Error starting %s: %s" % (path, e)) def _bus_name_appeared(self, name, owner, data): - log ("[%s] appeared in the bus as %s" % (self.PROCESS_NAME, owner)) + log("[%s] appeared in the bus as %s" % (self.PROCESS_NAME, owner)) self.available = True self.loop.quit() def _bus_name_vanished(self, name, data): - log ("[%s] disappeared from the bus" % self.PROCESS_NAME) + log("[%s] disappeared from the bus" % self.PROCESS_NAME) self.available = False self.loop.quit() - def _process_watch_cb (self): + def _process_watch_cb(self): if self.process_watch_timeout == 0: # The GLib seems to call the timeout after we've removed it # sometimes, which causes errors unless we detect it. return False - status = self.process.poll () + status = self.process.poll() if status is None: return True # continue @@ -124,15 +128,16 @@ class Helper: error = "" else: error = self.process.stderr.read() - raise RuntimeError("%s exited with status: %i\n%s" % (self.PROCESS_NAME, status, error)) + raise RuntimeError("%s exited with status: %i\n%s" % + (self.PROCESS_NAME, status, error)) - def _timeout_on_idle_cb (self): - log ("[%s] Timeout waiting... asumming idle." % self.PROCESS_NAME) - self.loop.quit () + def _timeout_on_idle_cb(self): + log("[%s] Timeout waiting... asumming idle." % self.PROCESS_NAME) + self.loop.quit() self.timeout_id = None return False - def start (self, env=None): + def start(self, env=None): """ Start an instance of process and wait for it to appear on the bus. """ @@ -146,25 +151,27 @@ class Helper: self.loop.run() if options.is_manual_start(): - print ("Start %s manually" % self.PROCESS_NAME) + print("Start %s manually" % self.PROCESS_NAME) else: if self.available: # It's running, but we didn't start it... - raise Exception ("Unable to start test instance of %s: " - "already running " % self.PROCESS_NAME) + raise Exception("Unable to start test instance of %s: " + "already running " % self.PROCESS_NAME) - self.process = self._start_process (env=env) - log ('[%s] Started process %i' % (self.PROCESS_NAME, self.process.pid)) - self.process_watch_timeout = GLib.timeout_add (200, self._process_watch_cb) + self.process = self._start_process(env=env) + log('[%s] Started process %i' % + (self.PROCESS_NAME, self.process.pid)) + self.process_watch_timeout = GLib.timeout_add( + 200, self._process_watch_cb) self.abort_if_process_exits_with_status_0 = True # Run the loop until the bus name appears, or the process dies. - self.loop.run () + self.loop.run() self.abort_if_process_exits_with_status_0 = False - def stop (self): + def stop(self): if self.process is None: # Seems that it didn't even start... return @@ -180,36 +187,37 @@ class Helper: time.sleep(0.1) if time.time() > (start + REASONABLE_TIMEOUT): - log ("[%s] Failed to terminate, sending kill!" % self.PROCESS_NAME) + log("[%s] Failed to terminate, sending kill!" % + self.PROCESS_NAME) self.process.kill() self.process.wait() - log ("[%s] stopped." % self.PROCESS_NAME) + log("[%s] stopped." % self.PROCESS_NAME) # Run the loop until the bus name appears, or the process dies. - self.loop.run () + self.loop.run() Gio.bus_unwatch_name(self._bus_name_watch_id) self.process = None - def kill (self): + def kill(self): if options.is_manual_start(): - log ("kill(): ignoring, because process was started manually.") + log("kill(): ignoring, because process was started manually.") return if self.process_watch_timeout != 0: GLib.source_remove(self.process_watch_timeout) self.process_watch_timeout = 0 - self.process.kill () + self.process.kill() # Name owner changed callback should take us out from this loop - self.loop.run () + self.loop.run() Gio.bus_unwatch_name(self._bus_name_watch_id) self.process = None - log ("[%s] killed." % self.PROCESS_NAME) + log("[%s] killed." % self.PROCESS_NAME) class StoreHelper (Helper): @@ -224,8 +232,8 @@ class StoreHelper (Helper): PROCESS_PATH = cfg.TRACKER_STORE_PATH BUS_NAME = cfg.TRACKER_BUSNAME - def start (self, env=None): - Helper.start (self, env=env) + def start(self, env=None): + Helper.start(self, env=env) self.resources = Gio.DBusProxy.new_sync( self.bus, Gio.DBusProxyFlags.DO_NOT_AUTO_START, None, @@ -243,50 +251,50 @@ class StoreHelper (Helper): self.bus, Gio.DBusProxyFlags.DO_NOT_AUTO_START, None, cfg.TRACKER_BUSNAME, cfg.TRACKER_STATUS_OBJ_PATH, cfg.STATUS_IFACE) - log ("[%s] booting..." % self.PROCESS_NAME) - self.status_iface.Wait () - log ("[%s] ready." % self.PROCESS_NAME) + log("[%s] booting..." % self.PROCESS_NAME) + self.status_iface.Wait() + log("[%s] ready." % self.PROCESS_NAME) - def stop (self): - Helper.stop (self) + def stop(self): + Helper.stop(self) - def query (self, query, timeout=5000, **kwargs): - return self.resources.SparqlQuery ('(s)', query, timeout=timeout, **kwargs) + def query(self, query, timeout=5000, **kwargs): + return self.resources.SparqlQuery('(s)', query, timeout=timeout, **kwargs) - def update (self, update_sparql, timeout=5000, **kwargs): - return self.resources.SparqlUpdate ('(s)', update_sparql, timeout=timeout, **kwargs) + def update(self, update_sparql, timeout=5000, **kwargs): + return self.resources.SparqlUpdate('(s)', update_sparql, timeout=timeout, **kwargs) - def load (self, ttl_uri, timeout=5000, **kwargs): - return self.resources.Load ('(s)', ttl_uri, timeout=timeout, **kwargs) + def load(self, ttl_uri, timeout=5000, **kwargs): + return self.resources.Load('(s)', ttl_uri, timeout=timeout, **kwargs) - def batch_update (self, update_sparql, **kwargs): - return self.resources.BatchSparqlUpdate ('(s)', update_sparql, **kwargs) + def batch_update(self, update_sparql, **kwargs): + return self.resources.BatchSparqlUpdate('(s)', update_sparql, **kwargs) - def batch_commit (self, **kwargs): - return self.resources.BatchCommit (**kwargs) + def batch_commit(self, **kwargs): + return self.resources.BatchCommit(**kwargs) - def backup (self, backup_file, **kwargs): - return self.backup_iface.Save ('(s)', backup_file, **kwargs) + def backup(self, backup_file, **kwargs): + return self.backup_iface.Save('(s)', backup_file, **kwargs) - def restore (self, backup_file, **kwargs): - return self.backup_iface.Restore ('(s)', backup_file, **kwargs) + def restore(self, backup_file, **kwargs): + return self.backup_iface.Restore('(s)', backup_file, **kwargs) - def get_stats (self, **kwargs): + def get_stats(self, **kwargs): return self.stats_iface.Get(**kwargs) - def get_tracker_iface (self): + def get_tracker_iface(self): return self.resources - def count_instances (self, ontology_class): + def count_instances(self, ontology_class): QUERY = """ SELECT COUNT(?u) WHERE { ?u a %s . } """ - result = self.resources.SparqlQuery ('(s)', QUERY % (ontology_class)) + result = self.resources.SparqlQuery('(s)', QUERY % (ontology_class)) - if (len (result) == 1): - return int (result [0][0]) + if (len(result) == 1): + return int(result[0][0]) else: return -1 @@ -297,11 +305,11 @@ class StoreHelper (Helper): result = self.query( 'SELECT tracker:id(%s) WHERE { }' % uri) if len(result) == 1: - return int (result [0][0]) + return int(result[0][0]) elif len(result) == 0: - raise Exception ("No entry for resource %s" % uri) + raise Exception("No entry for resource %s" % uri) else: - raise Exception ("Multiple entries for resource %s" % uri) + raise Exception("Multiple entries for resource %s" % uri) # FIXME: rename to get_resource_id_by_nepomuk_url !! def get_resource_id(self, url): @@ -311,19 +319,19 @@ class StoreHelper (Helper): result = self.query( 'SELECT tracker:id(?r) WHERE { ?r nie:url "%s" }' % url) if len(result) == 1: - return int (result [0][0]) + return int(result[0][0]) elif len(result) == 0: - raise Exception ("No entry for resource %s" % url) + raise Exception("No entry for resource %s" % url) else: - raise Exception ("Multiple entries for resource %s" % url) + raise Exception("Multiple entries for resource %s" % url) - def ask (self, ask_query): - assert ask_query.strip ().startswith ("ASK") - result = self.query (ask_query) - assert len (result) == 1 + def ask(self, ask_query): + assert ask_query.strip().startswith("ASK") + result = self.query(ask_query) + assert len(result) == 1 if result[0][0] == "true": return True elif result[0][0] == "false": return False else: - raise Exception ("Something fishy is going on") + raise Exception("Something fishy is going on") diff --git a/tests/functional-tests/common/utils/html.py b/tests/functional-tests/common/utils/html.py deleted file mode 100644 index ec296fe4d..000000000 --- a/tests/functional-tests/common/utils/html.py +++ /dev/null @@ -1,64 +0,0 @@ -#!/usr/bin/env python -import unittest -import os - -class html: - - def top(self): - - os.remove('indexing-performance') - self.file = 'indexing-performance' - self.f = open(self.file, "a") - self.f.write('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">' + "\n" + - '<html>' + "\n" + - ' <head>' + "\n" + - ' <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">' + "\n" + - ' <title>Tracker Indexing Performance</title>' + "\n" + - ' <H1 align="center"><font color="#CC0000" face="verdana" size="6">Tracker Indexing Performance</font></H1>' + "\n" + - ' <body>' + "\n" + - ' <table border="1", align="center">' + "\n" + - '<th><font color="#8000FF" face="verdana" size="4">Test data</font></th>' + "\n" + - '<th><font color="#8000FF" face="verdana" size="4">Minimum</font></th>' + "\n" + - '<th><font color="#8000FF" face="verdana" size="4">Maximum</font></th>' + "\n" + - '<th><font color="#8000FF" face="verdana" size="4">Average</font></th>' + "\n" + - '<th><font color="#8000FF" face="verdana" size="4">Median</font></th>' + "\n" - ) - self.f.close() - - - def mid(self,title,min,max,avg,median): - - self.file = 'indexing-performance' - self.f = open(self.file, "a") - self.f.write( '<tr>' + "\n" + - '<td>' + title + '</td>' + "\n" + - '<td>' + str(min) + '</td>' + "\n" + - '<td>' + str(max) + '</td>' + "\n" + - '<td>' + str(avg) + '</td>' + "\n" + - '<td>' + str(median) + '</td>' + "\n" + - '</tr>' + "\n" - ) - self.f.close() - - def bottom(self): - - self.file = 'indexing-performance' - self.f = open(self.file, "a") - self.f.write( '</table>' + "\n" + - ' </body>' + "\n" + - ' </head>' + "\n" + - ' </html>' + "\n" - ) - self.f.close() - -class report(unittest.TestCase): - - def first(self): - self.file = html() - self.file.top() - - def last(self): - self.file = html() - self.file.bottom() - - diff --git a/tests/functional-tests/common/utils/options.py b/tests/functional-tests/common/utils/options.py index 1b46cad94..d11d5a12f 100644 --- a/tests/functional-tests/common/utils/options.py +++ b/tests/functional-tests/common/utils/options.py @@ -1,5 +1,6 @@ import os + def get_environment_boolean(variable): '''Parse a yes/no boolean passed through the environment.''' @@ -12,12 +13,14 @@ def get_environment_boolean(variable): raise RuntimeError('Unexpected value for %s: %s' % (variable, value)) + def is_verbose(): """ True to log process status information to stdout """ return get_environment_boolean('TRACKER_TESTS_VERBOSE') + def is_manual_start(): """ False to start the processes automatically diff --git a/tests/functional-tests/common/utils/storetest.py b/tests/functional-tests/common/utils/storetest.py index febd49529..dad9a0ac6 100644 --- a/tests/functional-tests/common/utils/storetest.py +++ b/tests/functional-tests/common/utils/storetest.py @@ -29,17 +29,17 @@ from common.utils import configuration as cfg class CommonTrackerStoreTest (ut.TestCase): - """ - Common superclass for tests that just require a fresh store running - """ - @classmethod - def setUpClass (self): - env = os.environ - env['LC_COLLATE'] = 'en_GB.utf8' + """ + Common superclass for tests that just require a fresh store running + """ + @classmethod + def setUpClass(self): + env = os.environ + env['LC_COLLATE'] = 'en_GB.utf8' - self.tracker = StoreHelper() - self.tracker.start(env=env) + self.tracker = StoreHelper() + self.tracker.start(env=env) - @classmethod - def tearDownClass (self): - self.tracker.stop() + @classmethod + def tearDownClass(self): + self.tracker.stop() |