summaryrefslogtreecommitdiff
path: root/test/dbus/remote-test.py
diff options
context:
space:
mode:
Diffstat (limited to 'test/dbus/remote-test.py')
-rw-r--r--test/dbus/remote-test.py184
1 files changed, 92 insertions, 92 deletions
diff --git a/test/dbus/remote-test.py b/test/dbus/remote-test.py
index 4b2d1632..fdfdc5ab 100644
--- a/test/dbus/remote-test.py
+++ b/test/dbus/remote-test.py
@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#! /usr/bin/env python3
# -.- coding: utf-8 -.-
# remote-test.py
@@ -38,26 +38,26 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
# Insert an event
events = parse_events("test/data/single_event.js")
ids = self.insertEventsAndWait(events)
- self.assertEquals(1, len(ids))
+ self.assertEqual(1, len(ids))
# Now get it back and check it hasn't changed
retrieved_events = self.getEventsAndWait(ids)
- self.assertEquals(1, len(retrieved_events))
+ self.assertEqual(1, len(retrieved_events))
self.assertEventsEqual(retrieved_events[0], events[0])
def testUnicodeInsert(self):
events = parse_events("test/data/unicode_event.js")
ids = self.insertEventsAndWait(events)
- self.assertEquals(len(ids), len(events))
+ self.assertEqual(len(ids), len(events))
result_events = self.getEventsAndWait(ids)
- self.assertEquals(len(ids), len(result_events))
+ self.assertEqual(len(ids), len(result_events))
def testGetEvents(self):
events = parse_events("test/data/five_events.js")
ids = self.insertEventsAndWait(events) + [1000, 2000]
result = self.getEventsAndWait(ids)
- self.assertEquals(len(filter(None, result)), len(events))
- self.assertEquals(len(filter(lambda event: event is None, result)), 2)
+ self.assertEqual(len([_f for _f in result if _f]), len(events))
+ self.assertEqual(len([event for event in result if event is None]), 2)
def testInsertAndDeleteEvent(self):
# Insert an event
@@ -66,12 +66,12 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
# Delete it, make sure the returned time range is correct
time_range = self.deleteEventsAndWait(ids)
- self.assertEquals(time_range[0], time_range[1])
- self.assertEquals(time_range[0], int(events[0].timestamp))
+ self.assertEqual(time_range[0], time_range[1])
+ self.assertEqual(time_range[0], int(events[0].timestamp))
# Make sure the event is gone
retrieved_events = self.getEventsAndWait(ids)
- self.assertEquals(retrieved_events[0], None)
+ self.assertEqual(retrieved_events[0], None)
def testDeleteNonExistantEvent(self):
# Insert an event (populate the database so it isn't empty)
@@ -81,12 +81,12 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
# Try deleting a non-existant event
events = parse_events("test/data/single_event.js")
time_range = self.deleteEventsAndWait([int(ids[0]) + 1000])
- self.assertEquals(time_range[0], time_range[1])
- self.assertEquals(time_range[0], -1)
+ self.assertEqual(time_range[0], time_range[1])
+ self.assertEqual(time_range[0], -1)
# Make sure the inserted event is still there
retrieved_events = self.getEventsAndWait(ids)
- self.assertEquals(1, len(retrieved_events))
+ self.assertEqual(1, len(retrieved_events))
self.assertEventsEqual(retrieved_events[0], events[0])
def testDeleteTwoSimilarEvents(self):
@@ -101,7 +101,7 @@ class ZeitgeistRemoteAPITest(testutils.RemoteTestCase):
# Make sure it's gone, but the second one is still there
retrieved_events = self.getEventsAndWait(ids)
- self.assertEquals(retrieved_events[0], None)
+ self.assertEqual(retrieved_events[0], None)
self.assertEventsEqual(retrieved_events[1], event2)
class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
@@ -109,18 +109,18 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
def testFindTwoOfThreeEvents(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
- self.assertEquals(3, len(ids))
+ self.assertEqual(3, len(ids))
events = self.getEventsAndWait(ids)
- self.assertEquals(3, len(events))
+ self.assertEqual(3, len(events))
for event in events:
self.assertTrue(isinstance(event, Event))
- self.assertEquals(Manifestation.USER_ACTIVITY, event.manifestation)
+ self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
self.assertTrue(event.actor.startswith("Boogaloo"))
# Search for everything
ids = self.findEventIdsAndWait([], num_events=3)
- self.assertEquals(3, len(ids))
+ self.assertEqual(3, len(ids))
# Search for some specific templates
subj_templ1 = Subject.new_for_values(manifestation=Manifestation.FILE_DATA_OBJECT)
@@ -131,23 +131,23 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
subjects=[subj_templ1, subj_templ2])
ids = self.findEventIdsAndWait([event_template],
num_events=10)
- self.assertEquals(1, len(ids))
+ self.assertEqual(1, len(ids))
def testFindOneOfThreeEvents(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
- self.assertEquals(3, len(ids))
+ self.assertEqual(3, len(ids))
events = self.getEventsAndWait(ids)
- self.assertEquals(3, len(events))
+ self.assertEqual(3, len(events))
for event in events:
self.assertTrue(isinstance(event, Event))
- self.assertEquals(Manifestation.USER_ACTIVITY, event.manifestation)
+ self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
self.assertTrue(event.actor.startswith("Boogaloo"))
# Search for everything
ids = self.findEventIdsAndWait([], num_events=3)
- self.assertEquals(3, len(ids))
+ self.assertEqual(3, len(ids))
# Search for some specific templates
subj_templ1 = Subject.new_for_values(interpretation="!"+Interpretation.AUDIO)
@@ -158,21 +158,21 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
subjects=[subj_templ1, subj_templ2])
ids = self.findEventIdsAndWait([event_template],
num_events=10)
- self.assertEquals(1, len(ids))
+ self.assertEqual(1, len(ids))
events = self.getEventsAndWait(ids)
event = events[0]
- self.assertEquals(event.subjects[0].interpretation, Interpretation.DOCUMENT)
+ self.assertEqual(event.subjects[0].interpretation, Interpretation.DOCUMENT)
def testFindEventsWithMultipleSubjects(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
results = self.findEventsForTemplatesAndWait([], num_events=5)
- self.assertEquals(3, len(results))
+ self.assertEqual(3, len(results))
- self.assertEquals(len(results[2].get_subjects()), 2)
- self.assertEquals(len(results[1].get_subjects()), 1)
- self.assertEquals(len(results[0].get_subjects()), 1)
+ self.assertEqual(len(results[2].get_subjects()), 2)
+ self.assertEqual(len(results[1].get_subjects()), 1)
+ self.assertEqual(len(results[0].get_subjects()), 1)
def testFindEventsWithNoexpandOperator(self):
events = parse_events("test/data/three_events.js")
@@ -182,20 +182,20 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
subject_interpretation=Interpretation.MEDIA)
results = self.findEventsForTemplatesAndWait([template],
num_events=5)
- self.assertEquals(3, len(results))
+ self.assertEqual(3, len(results))
template = Event.new_for_values(
subject_interpretation='+%s' % Interpretation.MEDIA)
results = self.findEventsForTemplatesAndWait([template],
num_events=5)
- self.assertEquals(0, len(results))
+ self.assertEqual(0, len(results))
template = Event.new_for_values(
subject_interpretation='+%s' % Interpretation.AUDIO)
results = self.findEventsForTemplatesAndWait([template],
num_events=5)
- self.assertEquals(1, len(results))
- self.assertEquals(results[0].get_subjects()[0].interpretation,
+ self.assertEqual(1, len(results))
+ self.assertEqual(results[0].get_subjects()[0].interpretation,
Interpretation.AUDIO)
def testFindEventsLimitWhenDuplicates(self):
@@ -206,66 +206,66 @@ class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
# when some of them have multiple subjects (so more than one row
# with the same event id).
results = self.findEventsForTemplatesAndWait([], num_events=3)
- self.assertEquals(3, len(results))
+ self.assertEqual(3, len(results))
def testInsertWithEmptySubjectInterpretationManifestation(self):
events = parse_events("test/data/incomplete_events.js")
ids = self.insertEventsAndWait(events[:3])
- self.assertEquals(3, len(ids))
+ self.assertEqual(3, len(ids))
event = self.getEventsAndWait([ids[0]])[0]
- self.assertEquals("Hi", event.subjects[0].manifestation)
- self.assertEquals("", event.subjects[0].interpretation)
- self.assertEquals("Something", event.subjects[1].manifestation)
- self.assertEquals("", event.subjects[1].interpretation)
+ self.assertEqual("Hi", event.subjects[0].manifestation)
+ self.assertEqual("", event.subjects[0].interpretation)
+ self.assertEqual("Something", event.subjects[1].manifestation)
+ self.assertEqual("", event.subjects[1].interpretation)
event = self.getEventsAndWait([ids[1]])[0]
- self.assertEquals(Manifestation.FILE_DATA_OBJECT, event.subjects[0].manifestation)
- self.assertEquals(Interpretation.SOURCE_CODE, event.subjects[0].interpretation)
- self.assertEquals(Manifestation.FILE_DATA_OBJECT, event.subjects[1].manifestation)
- self.assertEquals("a", event.subjects[1].interpretation)
- self.assertEquals("b", event.subjects[2].manifestation)
- self.assertEquals(Interpretation.SOURCE_CODE, event.subjects[2].interpretation)
+ self.assertEqual(Manifestation.FILE_DATA_OBJECT, event.subjects[0].manifestation)
+ self.assertEqual(Interpretation.SOURCE_CODE, event.subjects[0].interpretation)
+ self.assertEqual(Manifestation.FILE_DATA_OBJECT, event.subjects[1].manifestation)
+ self.assertEqual("a", event.subjects[1].interpretation)
+ self.assertEqual("b", event.subjects[2].manifestation)
+ self.assertEqual(Interpretation.SOURCE_CODE, event.subjects[2].interpretation)
event = self.getEventsAndWait([ids[2]])[0]
- self.assertEquals("something else", event.subjects[0].manifestation)
- self.assertEquals("#Audio", event.subjects[0].interpretation)
+ self.assertEqual("something else", event.subjects[0].manifestation)
+ self.assertEqual("#Audio", event.subjects[0].interpretation)
def testInsertWithEmptySubjectMimeType(self):
events = parse_events("test/data/incomplete_events.js")
ids = self.insertEventsAndWait([events[7]])
- self.assertEquals(1, len(ids))
+ self.assertEqual(1, len(ids))
event = self.getEventsAndWait([ids[0]])[0]
- self.assertEquals(1, len(event.subjects))
+ self.assertEqual(1, len(event.subjects))
subject = event.subjects[0]
- self.assertEquals("file:///unknown-mimetype-file", subject.uri)
- self.assertEquals("", subject.mimetype)
- self.assertEquals(Manifestation.FILE_DATA_OBJECT, subject.manifestation) # FIXME
- self.assertEquals("", subject.interpretation) # FIXME
+ self.assertEqual("file:///unknown-mimetype-file", subject.uri)
+ self.assertEqual("", subject.mimetype)
+ self.assertEqual(Manifestation.FILE_DATA_OBJECT, subject.manifestation) # FIXME
+ self.assertEqual("", subject.interpretation) # FIXME
def testInsertIncompleteEvent(self):
events = parse_events("test/data/incomplete_events.js")
# Missing interpretation
ids = self.insertEventsAndWait([events[3]])
- self.assertEquals(0, len(ids))
+ self.assertEqual(0, len(ids))
# Missing manifestation
ids = self.insertEventsAndWait([events[4]])
- self.assertEquals(0, len(ids))
+ self.assertEqual(0, len(ids))
# Missing actor
ids = self.insertEventsAndWait([events[5]])
- self.assertEquals(0, len(ids))
+ self.assertEqual(0, len(ids))
def testInsertIncompleteSubject(self):
events = parse_events("test/data/incomplete_events.js")
# Missing one subject URI
ids = self.insertEventsAndWait([events[6]])
- self.assertEquals(0, len(ids))
+ self.assertEqual(0, len(ids))
class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
"""
@@ -286,172 +286,172 @@ class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
def testFindEventIds(self):
# Retrieve all existing event IDs, make sure they are correct
retrieved_ids = self.findEventIdsAndWait([])
- self.assertEquals(set(retrieved_ids), set(self.ids))
+ self.assertEqual(set(retrieved_ids), set(self.ids))
def testFindEventIdsForId(self):
# Retrieve events for a particular event ID
template = Event([["3", "", "", "", "", ""], [], ""])
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [3])
+ self.assertEqual(ids, [3])
def testFindEventIdsForTimeRange(self):
# Make sure that filtering by time range we get the right ones
retrieved_ids = self.findEventIdsAndWait([],
timerange=TimeRange(133, 153))
- self.assertEquals(retrieved_ids, [4, 2, 3]) # TS: [133, 143, 153]
+ self.assertEqual(retrieved_ids, [4, 2, 3]) # TS: [133, 143, 153]
retrieved_ids = self.findEventIdsAndWait([],
timerange=TimeRange(163, 163))
- self.assertEquals(retrieved_ids, [5]) # Timestamps: [163]
+ self.assertEqual(retrieved_ids, [5]) # Timestamps: [163]
def testFindEventIdsForInterpretation(self):
# Retrieve events for a particular interpretation
template = Event.new_for_values(interpretation='stfu:OpenEvent')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [5, 1])
+ self.assertEqual(ids, [5, 1])
# Retrieve events excluding a particular interpretation
template = Event.new_for_values(interpretation='!stfu:OpenEvent')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [4, 2, 3])
+ self.assertEqual(list(map(int, ids)), [4, 2, 3])
def testFindEventIdsForManifestation(self):
# Retrieve events for a particular manifestation
template = Event.new_for_values(manifestation='stfu:BooActivity')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [2])
+ self.assertEqual(ids, [2])
# Retrieve events excluding a particular manifestation
template = Event.new_for_values(manifestation='!stfu:BooActivity')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 4, 3, 1])
+ self.assertEqual(list(map(int, ids)), [5, 4, 3, 1])
def testFindEventIdsForActor(self):
# Retrieve events for a particular actor
template = Event.new_for_values(actor='gedit')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [3])
+ self.assertEqual(ids, [3])
# Retrieve events excluding a particular actor
template = Event.new_for_values(actor='!gedit')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 4, 2, 1])
+ self.assertEqual(list(map(int, ids)), [5, 4, 2, 1])
# Retrieve events with actor matching a prefix
template = Event.new_for_values(actor='g*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [2, 3])
+ self.assertEqual(list(map(int, ids)), [2, 3])
def testFindEventIdsForEventOrigin(self):
# Retrieve events for a particular actor
template = Event.new_for_values(origin='big bang')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [5, 3])
+ self.assertEqual(ids, [5, 3])
# Now let's try with wildcard and negation
template = Event.new_for_values(origin='!big *')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [4, 2, 1])
+ self.assertEqual(list(map(int, ids)), [4, 2, 1])
def testFindEventIdsForSubjectInterpretation(self):
# Retrieve events for a particular subject interpretation
template = Event.new_for_values(subject_interpretation='stfu:Document')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [1])
+ self.assertEqual(ids, [1])
# Retrieve events excluding a particular subject interpretation
template = Event.new_for_values(subject_interpretation='!stfu:Document')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 4, 2, 3])
+ self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
def testFindEventIdsForSubjectManifestation(self):
# Retrieve events for a particular subject manifestation
template = Event.new_for_values(subject_manifestation='stfu:File')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [5, 4, 3, 1])
+ self.assertEqual(ids, [5, 4, 3, 1])
# Retrieve events excluding a particular subject interpretation
template = Event.new_for_values(subject_manifestation='!stfu:File')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [2])
+ self.assertEqual(list(map(int, ids)), [2])
def testFindEventIdsForSubjectMimeType(self):
# Retrieve events for a particular mime-type
template = Event.new_for_values(subject_mimetype='text/plain')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [4, 2, 3])
+ self.assertEqual(ids, [4, 2, 3])
# Now let's try with wildcard and negation
template = Event.new_for_values(subject_mimetype='!meat/*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 4, 2, 3])
+ self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
def testFindEventIdsForSubjectUri(self):
# Retrieve events for a particular URI
template = Event.new_for_values(subject_uri='file:///tmp/foo.txt')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [2, 3])
+ self.assertEqual(ids, [2, 3])
# Now let's try with wildcard...
template = Event.new_for_values(subject_uri='http://*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [1])
+ self.assertEqual(list(map(int, ids)), [1])
# ... and negation
template = Event.new_for_values(subject_uri='!file:///tmp/foo.txt')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 4, 1])
+ self.assertEqual(list(map(int, ids)), [5, 4, 1])
def testFindEventIdsForSubjectOrigin(self):
# Retrieve events for a particular origin
template = Event.new_for_values(subject_origin='file:///tmp')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [4, 2, 3])
+ self.assertEqual(ids, [4, 2, 3])
# Now let's try with wildcard and negation
template = Event.new_for_values(subject_origin='!file:*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 1])
+ self.assertEqual(list(map(int, ids)), [5, 1])
def testFindEventIdsForSubjectText(self):
# Retrieve events with a particular text
template = Event.new_for_values(subject_text='this item *')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [4])
+ self.assertEqual(ids, [4])
def testFindEventIdsForSubjectCurrentUri(self):
# Retrieve events for a particular current URI
template = Event.new_for_values(subject_current_uri='http://www.google.de')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [1])
+ self.assertEqual(ids, [1])
# Now let's try with wildcard and negation
template = Event.new_for_values(subject_current_uri='!http:*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 4, 2, 3])
+ self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
def testFindEventIdsForSubjectCurrentOrigin(self):
# Retrieve events for a particular current origin
template = Event.new_for_values(subject_current_origin='file:///tmp')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [4, 2, 3])
+ self.assertEqual(ids, [4, 2, 3])
# Now let's try with wildcard and negation
template = Event.new_for_values(subject_current_origin='!file:*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [5, 1])
+ self.assertEqual(list(map(int, ids)), [5, 1])
# Now let's try with wildcard and negation
template = Event.new_for_values(subject_current_origin='!http:*')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(map(int, ids), [4, 2, 3])
+ self.assertEqual(list(map(int, ids)), [4, 2, 3])
def testFindEventIdsForSubjectStorage(self):
# Retrieve events for a particular subject storage
template = Event.new_for_values(subject_storage=
'368c991f-8b59-4018-8130-3ce0ec944157')
ids = self.findEventIdsAndWait([template])
- self.assertEquals(ids, [4, 2, 3, 1])
+ self.assertEqual(ids, [4, 2, 3, 1])
def testFindEventIdsWithStorageState(self):
"""
@@ -463,16 +463,16 @@ class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
# Retrieve events with storage state "any"
ids = self.findEventIdsAndWait([], storage_state=StorageState.Any)
- self.assertEquals(ids, [5, 4, 2, 3, 1])
+ self.assertEqual(ids, [5, 4, 2, 3, 1])
# Retrieve events with storage state "available"
ids = self.findEventIdsAndWait([], storage_state=StorageState.Available)
- self.assertEquals(ids, [5, 4, 2, 3, 1])
+ self.assertEqual(ids, [5, 4, 2, 3, 1])
# Retrieve events with storage state "not available"
ids = self.findEventIdsAndWait([],
storage_state=StorageState.NotAvailable)
- self.assertEquals(ids, [5, 4, 2, 3, 1])
+ self.assertEqual(ids, [5, 4, 2, 3, 1])
def testFindEventIdsWithUnknownStorageState(self):
"""
@@ -488,7 +488,7 @@ class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
tmpl = Event.new_for_values(subject_uri='file:///i-am-unknown')
ids = self.findEventIdsAndWait([tmpl], storage_state=StorageState.Available)
- self.assertEquals(ids, [6])
+ self.assertEqual(ids, [6])
class ZeitgeistRemoteInterfaceTest(testutils.RemoteTestCase):
View Lorry Controller Status