← Back to branch summary

~zeitgeist/zeitgeist/trunk-freedesktop

« back to all changes in this revision

Viewing changes to test/dbus/remote-test.py

  • Committer: crvi
  • Date: 2020-08-13 21:54:56 UTC
  • Revision ID: git-v1:6523379927f7a67dc96897fd5075e427d6d7cb6b
test: port dbus tests to python3

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/dbus/remote-test.py
1
 
#! /usr/bin/env python
 
1
#! /usr/bin/env python3
2
2
# -.- coding: utf-8 -.-
3
3
 
4
4
# remote-test.py
38
38
                # Insert an event
39
39
                events = parse_events("test/data/single_event.js")
40
40
                ids = self.insertEventsAndWait(events)
41
 
                self.assertEquals(1, len(ids))
 
41
                self.assertEqual(1, len(ids))
42
42
 
43
43
                # Now get it back and check it hasn't changed
44
44
                retrieved_events = self.getEventsAndWait(ids)
45
 
                self.assertEquals(1, len(retrieved_events))
 
45
                self.assertEqual(1, len(retrieved_events))
46
46
                self.assertEventsEqual(retrieved_events[0], events[0])
47
47
 
48
48
        def testUnicodeInsert(self):
49
49
                events = parse_events("test/data/unicode_event.js")
50
50
                ids = self.insertEventsAndWait(events)
51
 
                self.assertEquals(len(ids), len(events))
 
51
                self.assertEqual(len(ids), len(events))
52
52
                result_events = self.getEventsAndWait(ids)
53
 
                self.assertEquals(len(ids), len(result_events))
 
53
                self.assertEqual(len(ids), len(result_events))
54
54
 
55
55
        def testGetEvents(self):
56
56
                events = parse_events("test/data/five_events.js")
57
57
                ids = self.insertEventsAndWait(events) + [1000, 2000]
58
58
                result = self.getEventsAndWait(ids)
59
 
                self.assertEquals(len(filter(None, result)), len(events))
60
 
                self.assertEquals(len(filter(lambda event: event is None, result)), 2)
 
59
                self.assertEqual(len([_f for _f in result if _f]), len(events))
 
60
                self.assertEqual(len([event for event in result if event is None]), 2)
61
61
 
62
62
        def testInsertAndDeleteEvent(self):
63
63
                # Insert an event
66
66
 
67
67
                # Delete it, make sure the returned time range is correct
68
68
                time_range = self.deleteEventsAndWait(ids)
69
 
                self.assertEquals(time_range[0], time_range[1])
70
 
                self.assertEquals(time_range[0], int(events[0].timestamp))
 
69
                self.assertEqual(time_range[0], time_range[1])
 
70
                self.assertEqual(time_range[0], int(events[0].timestamp))
71
71
 
72
72
                # Make sure the event is gone
73
73
                retrieved_events = self.getEventsAndWait(ids)
74
 
                self.assertEquals(retrieved_events[0], None)
 
74
                self.assertEqual(retrieved_events[0], None)
75
75
 
76
76
        def testDeleteNonExistantEvent(self):
77
77
                # Insert an event (populate the database so it isn't empty)
81
81
                # Try deleting a non-existant event
82
82
                events = parse_events("test/data/single_event.js")
83
83
                time_range = self.deleteEventsAndWait([int(ids[0]) + 1000])
84
 
                self.assertEquals(time_range[0], time_range[1])
85
 
                self.assertEquals(time_range[0], -1)
 
84
                self.assertEqual(time_range[0], time_range[1])
 
85
                self.assertEqual(time_range[0], -1)
86
86
 
87
87
                # Make sure the inserted event is still there
88
88
                retrieved_events = self.getEventsAndWait(ids)
89
 
                self.assertEquals(1, len(retrieved_events))
 
89
                self.assertEqual(1, len(retrieved_events))
90
90
                self.assertEventsEqual(retrieved_events[0], events[0])
91
91
 
92
92
        def testDeleteTwoSimilarEvents(self):
101
101
 
102
102
                # Make sure it's gone, but the second one is still there
103
103
                retrieved_events = self.getEventsAndWait(ids)
104
 
                self.assertEquals(retrieved_events[0], None)
 
104
                self.assertEqual(retrieved_events[0], None)
105
105
                self.assertEventsEqual(retrieved_events[1], event2)
106
106
 
107
107
class ZeitgeistRemoteAPITestAdvanced(testutils.RemoteTestCase):
109
109
        def testFindTwoOfThreeEvents(self):
110
110
                events = parse_events("test/data/three_events.js")
111
111
                ids = self.insertEventsAndWait(events)
112
 
                self.assertEquals(3, len(ids))
 
112
                self.assertEqual(3, len(ids))
113
113
                
114
114
                events = self.getEventsAndWait(ids)
115
 
                self.assertEquals(3, len(events))               
 
115
                self.assertEqual(3, len(events))
116
116
                for event in events:
117
117
                        self.assertTrue(isinstance(event, Event))
118
 
                        self.assertEquals(Manifestation.USER_ACTIVITY, event.manifestation)
 
118
                        self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
119
119
                        self.assertTrue(event.actor.startswith("Boogaloo"))
120
120
                
121
121
                # Search for everything
122
122
                ids = self.findEventIdsAndWait([], num_events=3)
123
 
                self.assertEquals(3, len(ids))
 
123
                self.assertEqual(3, len(ids))
124
124
                
125
125
                # Search for some specific templates
126
126
                subj_templ1 = Subject.new_for_values(manifestation=Manifestation.FILE_DATA_OBJECT)
131
131
                                        subjects=[subj_templ1, subj_templ2])
132
132
                ids = self.findEventIdsAndWait([event_template],
133
133
                                                num_events=10)
134
 
                self.assertEquals(1, len(ids))
 
134
                self.assertEqual(1, len(ids))
135
135
 
136
136
        def testFindOneOfThreeEvents(self):
137
137
                events = parse_events("test/data/three_events.js")
138
138
                ids = self.insertEventsAndWait(events)
139
 
                self.assertEquals(3, len(ids))
 
139
                self.assertEqual(3, len(ids))
140
140
                
141
141
                events = self.getEventsAndWait(ids)
142
 
                self.assertEquals(3, len(events))
 
142
                self.assertEqual(3, len(events))
143
143
                for event in events:
144
144
                        self.assertTrue(isinstance(event, Event))
145
 
                        self.assertEquals(Manifestation.USER_ACTIVITY, event.manifestation)
 
145
                        self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
146
146
                        self.assertTrue(event.actor.startswith("Boogaloo"))
147
147
                
148
148
                # Search for everything
149
149
                ids = self.findEventIdsAndWait([], num_events=3)
150
 
                self.assertEquals(3, len(ids))
 
150
                self.assertEqual(3, len(ids))
151
151
                
152
152
                # Search for some specific templates
153
153
                subj_templ1 = Subject.new_for_values(interpretation="!"+Interpretation.AUDIO)
158
158
                                        subjects=[subj_templ1, subj_templ2])
159
159
                ids = self.findEventIdsAndWait([event_template],
160
160
                                                num_events=10)
161
 
                self.assertEquals(1, len(ids))
 
161
                self.assertEqual(1, len(ids))
162
162
                events = self.getEventsAndWait(ids)
163
163
                event = events[0]
164
 
                self.assertEquals(event.subjects[0].interpretation, Interpretation.DOCUMENT)
 
164
                self.assertEqual(event.subjects[0].interpretation, Interpretation.DOCUMENT)
165
165
 
166
166
        def testFindEventsWithMultipleSubjects(self):
167
167
                events = parse_events("test/data/three_events.js")
168
168
                ids = self.insertEventsAndWait(events)
169
169
 
170
170
                results = self.findEventsForTemplatesAndWait([], num_events=5)
171
 
                self.assertEquals(3, len(results))
 
171
                self.assertEqual(3, len(results))
172
172
 
173
 
                self.assertEquals(len(results[2].get_subjects()), 2)
174
 
                self.assertEquals(len(results[1].get_subjects()), 1)
175
 
                self.assertEquals(len(results[0].get_subjects()), 1)
 
173
                self.assertEqual(len(results[2].get_subjects()), 2)
 
174
                self.assertEqual(len(results[1].get_subjects()), 1)
 
175
                self.assertEqual(len(results[0].get_subjects()), 1)
176
176
 
177
177
        def testFindEventsWithNoexpandOperator(self):
178
178
                events = parse_events("test/data/three_events.js")
182
182
                        subject_interpretation=Interpretation.MEDIA)
183
183
                results = self.findEventsForTemplatesAndWait([template],
184
184
                        num_events=5)
185
 
                self.assertEquals(3, len(results))
 
185
                self.assertEqual(3, len(results))
186
186
 
187
187
                template = Event.new_for_values(
188
188
                        subject_interpretation='+%s' % Interpretation.MEDIA)
189
189
                results = self.findEventsForTemplatesAndWait([template],
190
190
                        num_events=5)
191
 
                self.assertEquals(0, len(results))
 
191
                self.assertEqual(0, len(results))
192
192
 
193
193
                template = Event.new_for_values(
194
194
                        subject_interpretation='+%s' % Interpretation.AUDIO)
195
195
                results = self.findEventsForTemplatesAndWait([template],
196
196
                        num_events=5)
197
 
                self.assertEquals(1, len(results))
198
 
                self.assertEquals(results[0].get_subjects()[0].interpretation,
 
197
                self.assertEqual(1, len(results))
 
198
                self.assertEqual(results[0].get_subjects()[0].interpretation,
199
199
                        Interpretation.AUDIO)
200
200
 
201
201
        def testFindEventsLimitWhenDuplicates(self):
206
206
                # when some of them have multiple subjects (so more than one row
207
207
                # with the same event id).
208
208
                results = self.findEventsForTemplatesAndWait([], num_events=3)
209
 
                self.assertEquals(3, len(results))
 
209
                self.assertEqual(3, len(results))
210
210
 
211
211
        def testInsertWithEmptySubjectInterpretationManifestation(self):
212
212
                events = parse_events("test/data/incomplete_events.js")
213
213
                ids = self.insertEventsAndWait(events[:3])
214
 
                self.assertEquals(3, len(ids))
 
214
                self.assertEqual(3, len(ids))
215
215
 
216
216
                event = self.getEventsAndWait([ids[0]])[0]
217
 
                self.assertEquals("Hi", event.subjects[0].manifestation)
218
 
                self.assertEquals("", event.subjects[0].interpretation)
219
 
                self.assertEquals("Something", event.subjects[1].manifestation)
220
 
                self.assertEquals("", event.subjects[1].interpretation)
 
217
                self.assertEqual("Hi", event.subjects[0].manifestation)
 
218
                self.assertEqual("", event.subjects[0].interpretation)
 
219
                self.assertEqual("Something", event.subjects[1].manifestation)
 
220
                self.assertEqual("", event.subjects[1].interpretation)
221
221
 
222
222
                event = self.getEventsAndWait([ids[1]])[0]
223
 
                self.assertEquals(Manifestation.FILE_DATA_OBJECT, event.subjects[0].manifestation)
224
 
                self.assertEquals(Interpretation.SOURCE_CODE, event.subjects[0].interpretation)
225
 
                self.assertEquals(Manifestation.FILE_DATA_OBJECT, event.subjects[1].manifestation)
226
 
                self.assertEquals("a", event.subjects[1].interpretation)
227
 
                self.assertEquals("b", event.subjects[2].manifestation)
228
 
                self.assertEquals(Interpretation.SOURCE_CODE, event.subjects[2].interpretation)
 
223
                self.assertEqual(Manifestation.FILE_DATA_OBJECT, event.subjects[0].manifestation)
 
224
                self.assertEqual(Interpretation.SOURCE_CODE, event.subjects[0].interpretation)
 
225
                self.assertEqual(Manifestation.FILE_DATA_OBJECT, event.subjects[1].manifestation)
 
226
                self.assertEqual("a", event.subjects[1].interpretation)
 
227
                self.assertEqual("b", event.subjects[2].manifestation)
 
228
                self.assertEqual(Interpretation.SOURCE_CODE, event.subjects[2].interpretation)
229
229
                
230
230
                event = self.getEventsAndWait([ids[2]])[0]
231
 
                self.assertEquals("something else", event.subjects[0].manifestation)
232
 
                self.assertEquals("#Audio", event.subjects[0].interpretation)
 
231
                self.assertEqual("something else", event.subjects[0].manifestation)
 
232
                self.assertEqual("#Audio", event.subjects[0].interpretation)
233
233
 
234
234
        def testInsertWithEmptySubjectMimeType(self):
235
235
                events = parse_events("test/data/incomplete_events.js")
236
236
                ids = self.insertEventsAndWait([events[7]])
237
 
                self.assertEquals(1, len(ids))
 
237
                self.assertEqual(1, len(ids))
238
238
                
239
239
                event = self.getEventsAndWait([ids[0]])[0]
240
 
                self.assertEquals(1, len(event.subjects))
 
240
                self.assertEqual(1, len(event.subjects))
241
241
 
242
242
                subject = event.subjects[0]
243
 
                self.assertEquals("file:///unknown-mimetype-file", subject.uri)
244
 
                self.assertEquals("", subject.mimetype)
245
 
                self.assertEquals(Manifestation.FILE_DATA_OBJECT, subject.manifestation)  # FIXME
246
 
                self.assertEquals("", subject.interpretation) # FIXME
 
243
                self.assertEqual("file:///unknown-mimetype-file", subject.uri)
 
244
                self.assertEqual("", subject.mimetype)
 
245
                self.assertEqual(Manifestation.FILE_DATA_OBJECT, subject.manifestation)  # FIXME
 
246
                self.assertEqual("", subject.interpretation) # FIXME
247
247
 
248
248
        def testInsertIncompleteEvent(self):
249
249
                events = parse_events("test/data/incomplete_events.js")
250
250
 
251
251
                # Missing interpretation
252
252
                ids = self.insertEventsAndWait([events[3]])
253
 
                self.assertEquals(0, len(ids))
 
253
                self.assertEqual(0, len(ids))
254
254
 
255
255
                # Missing manifestation
256
256
                ids = self.insertEventsAndWait([events[4]])
257
 
                self.assertEquals(0, len(ids))
 
257
                self.assertEqual(0, len(ids))
258
258
 
259
259
                # Missing actor
260
260
                ids = self.insertEventsAndWait([events[5]])
261
 
                self.assertEquals(0, len(ids))
 
261
                self.assertEqual(0, len(ids))
262
262
 
263
263
        def testInsertIncompleteSubject(self):
264
264
                events = parse_events("test/data/incomplete_events.js")
265
265
 
266
266
                # Missing one subject URI
267
267
                ids = self.insertEventsAndWait([events[6]])
268
 
                self.assertEquals(0, len(ids))
 
268
                self.assertEqual(0, len(ids))
269
269
 
270
270
class ZeitgeistRemoteFindEventIdsTest(testutils.RemoteTestCase):
271
271
        """
286
286
        def testFindEventIds(self):
287
287
                # Retrieve all existing event IDs, make sure they are correct
288
288
                retrieved_ids = self.findEventIdsAndWait([])
289
 
                self.assertEquals(set(retrieved_ids), set(self.ids))
 
289
                self.assertEqual(set(retrieved_ids), set(self.ids))
290
290
 
291
291
        def testFindEventIdsForId(self):
292
292
                # Retrieve events for a particular event ID 
293
293
                template = Event([["3", "", "", "", "", ""], [], ""])
294
294
                ids = self.findEventIdsAndWait([template])
295
 
                self.assertEquals(ids, [3])
 
295
                self.assertEqual(ids, [3])
296
296
 
297
297
        def testFindEventIdsForTimeRange(self):
298
298
                # Make sure that filtering by time range we get the right ones
299
299
                retrieved_ids = self.findEventIdsAndWait([],
300
300
                        timerange=TimeRange(133, 153))
301
 
                self.assertEquals(retrieved_ids, [4, 2, 3]) # TS: [133, 143, 153]
 
301
                self.assertEqual(retrieved_ids, [4, 2, 3]) # TS: [133, 143, 153]
302
302
 
303
303
                retrieved_ids = self.findEventIdsAndWait([],
304
304
                        timerange=TimeRange(163, 163))
305
 
                self.assertEquals(retrieved_ids, [5]) # Timestamps: [163]
 
305
                self.assertEqual(retrieved_ids, [5]) # Timestamps: [163]
306
306
 
307
307
        def testFindEventIdsForInterpretation(self):
308
308
                # Retrieve events for a particular interpretation
309
309
                template = Event.new_for_values(interpretation='stfu:OpenEvent')
310
310
                ids = self.findEventIdsAndWait([template])
311
 
                self.assertEquals(ids, [5, 1])
 
311
                self.assertEqual(ids, [5, 1])
312
312
 
313
313
                # Retrieve events excluding a particular interpretation
314
314
                template = Event.new_for_values(interpretation='!stfu:OpenEvent')
315
315
                ids = self.findEventIdsAndWait([template])
316
 
                self.assertEquals(map(int, ids), [4, 2, 3])
 
316
                self.assertEqual(list(map(int, ids)), [4, 2, 3])
317
317
 
318
318
        def testFindEventIdsForManifestation(self):
319
319
                # Retrieve events for a particular manifestation
320
320
                template = Event.new_for_values(manifestation='stfu:BooActivity')
321
321
                ids = self.findEventIdsAndWait([template])
322
 
                self.assertEquals(ids, [2])
 
322
                self.assertEqual(ids, [2])
323
323
 
324
324
                # Retrieve events excluding a particular manifestation
325
325
                template = Event.new_for_values(manifestation='!stfu:BooActivity')
326
326
                ids = self.findEventIdsAndWait([template])
327
 
                self.assertEquals(map(int, ids), [5, 4, 3, 1])
 
327
                self.assertEqual(list(map(int, ids)), [5, 4, 3, 1])
328
328
 
329
329
        def testFindEventIdsForActor(self):
330
330
                # Retrieve events for a particular actor
331
331
                template = Event.new_for_values(actor='gedit')
332
332
                ids = self.findEventIdsAndWait([template])
333
 
                self.assertEquals(ids, [3])
 
333
                self.assertEqual(ids, [3])
334
334
 
335
335
                # Retrieve events excluding a particular actor
336
336
                template = Event.new_for_values(actor='!gedit')
337
337
                ids = self.findEventIdsAndWait([template])
338
 
                self.assertEquals(map(int, ids), [5, 4, 2, 1])
 
338
                self.assertEqual(list(map(int, ids)), [5, 4, 2, 1])
339
339
 
340
340
                # Retrieve events with actor matching a prefix
341
341
                template = Event.new_for_values(actor='g*')
342
342
                ids = self.findEventIdsAndWait([template])
343
 
                self.assertEquals(map(int, ids), [2, 3])
 
343
                self.assertEqual(list(map(int, ids)), [2, 3])
344
344
 
345
345
        def testFindEventIdsForEventOrigin(self):
346
346
                # Retrieve events for a particular actor
347
347
                template = Event.new_for_values(origin='big bang')
348
348
                ids = self.findEventIdsAndWait([template])
349
 
                self.assertEquals(ids, [5, 3])
 
349
                self.assertEqual(ids, [5, 3])
350
350
 
351
351
                # Now let's try with wildcard and negation
352
352
                template = Event.new_for_values(origin='!big *')
353
353
                ids = self.findEventIdsAndWait([template])
354
 
                self.assertEquals(map(int, ids), [4, 2, 1])
 
354
                self.assertEqual(list(map(int, ids)), [4, 2, 1])
355
355
 
356
356
        def testFindEventIdsForSubjectInterpretation(self):
357
357
                # Retrieve events for a particular subject interpretation
358
358
                template = Event.new_for_values(subject_interpretation='stfu:Document')
359
359
                ids = self.findEventIdsAndWait([template])
360
 
                self.assertEquals(ids, [1])
 
360
                self.assertEqual(ids, [1])
361
361
 
362
362
                # Retrieve events excluding a particular subject interpretation
363
363
                template = Event.new_for_values(subject_interpretation='!stfu:Document')
364
364
                ids = self.findEventIdsAndWait([template])
365
 
                self.assertEquals(map(int, ids), [5, 4, 2, 3])
 
365
                self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
366
366
 
367
367
        def testFindEventIdsForSubjectManifestation(self):
368
368
                # Retrieve events for a particular subject manifestation
369
369
                template = Event.new_for_values(subject_manifestation='stfu:File')
370
370
                ids = self.findEventIdsAndWait([template])
371
 
                self.assertEquals(ids, [5, 4, 3, 1])
 
371
                self.assertEqual(ids, [5, 4, 3, 1])
372
372
 
373
373
                # Retrieve events excluding a particular subject interpretation
374
374
                template = Event.new_for_values(subject_manifestation='!stfu:File')
375
375
                ids = self.findEventIdsAndWait([template])
376
 
                self.assertEquals(map(int, ids), [2])
 
376
                self.assertEqual(list(map(int, ids)), [2])
377
377
 
378
378
        def testFindEventIdsForSubjectMimeType(self):
379
379
                # Retrieve events for a particular mime-type
380
380
                template = Event.new_for_values(subject_mimetype='text/plain')
381
381
                ids = self.findEventIdsAndWait([template])
382
 
                self.assertEquals(ids, [4, 2, 3])
 
382
                self.assertEqual(ids, [4, 2, 3])
383
383
 
384
384
                # Now let's try with wildcard and negation
385
385
                template = Event.new_for_values(subject_mimetype='!meat/*')
386
386
                ids = self.findEventIdsAndWait([template])
387
 
                self.assertEquals(map(int, ids), [5, 4, 2, 3])
 
387
                self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
388
388
 
389
389
        def testFindEventIdsForSubjectUri(self):
390
390
                # Retrieve events for a particular URI
391
391
                template = Event.new_for_values(subject_uri='file:///tmp/foo.txt')
392
392
                ids = self.findEventIdsAndWait([template])
393
 
                self.assertEquals(ids, [2, 3])
 
393
                self.assertEqual(ids, [2, 3])
394
394
 
395
395
                # Now let's try with wildcard...
396
396
                template = Event.new_for_values(subject_uri='http://*')
397
397
                ids = self.findEventIdsAndWait([template])
398
 
                self.assertEquals(map(int, ids), [1])
 
398
                self.assertEqual(list(map(int, ids)), [1])
399
399
 
400
400
                # ... and negation
401
401
                template = Event.new_for_values(subject_uri='!file:///tmp/foo.txt')
402
402
                ids = self.findEventIdsAndWait([template])
403
 
                self.assertEquals(map(int, ids), [5, 4, 1])
 
403
                self.assertEqual(list(map(int, ids)), [5, 4, 1])
404
404
 
405
405
        def testFindEventIdsForSubjectOrigin(self):
406
406
                # Retrieve events for a particular origin
407
407
                template = Event.new_for_values(subject_origin='file:///tmp')
408
408
                ids = self.findEventIdsAndWait([template])
409
 
                self.assertEquals(ids, [4, 2, 3])
 
409
                self.assertEqual(ids, [4, 2, 3])
410
410
 
411
411
                # Now let's try with wildcard and negation
412
412
                template = Event.new_for_values(subject_origin='!file:*')
413
413
                ids = self.findEventIdsAndWait([template])
414
 
                self.assertEquals(map(int, ids), [5, 1])
 
414
                self.assertEqual(list(map(int, ids)), [5, 1])
415
415
 
416
416
        def testFindEventIdsForSubjectText(self):
417
417
                # Retrieve events with a particular text
418
418
                template = Event.new_for_values(subject_text='this item *')
419
419
                ids = self.findEventIdsAndWait([template])
420
 
                self.assertEquals(ids, [4])
 
420
                self.assertEqual(ids, [4])
421
421
 
422
422
        def testFindEventIdsForSubjectCurrentUri(self):
423
423
                # Retrieve events for a particular current URI
424
424
                template = Event.new_for_values(subject_current_uri='http://www.google.de')
425
425
                ids = self.findEventIdsAndWait([template])
426
 
                self.assertEquals(ids, [1])
 
426
                self.assertEqual(ids, [1])
427
427
 
428
428
                # Now let's try with wildcard and negation
429
429
                template = Event.new_for_values(subject_current_uri='!http:*')
430
430
                ids = self.findEventIdsAndWait([template])
431
 
                self.assertEquals(map(int, ids), [5, 4, 2, 3])
 
431
                self.assertEqual(list(map(int, ids)), [5, 4, 2, 3])
432
432
 
433
433
        def testFindEventIdsForSubjectCurrentOrigin(self):
434
434
                # Retrieve events for a particular current origin
435
435
                template = Event.new_for_values(subject_current_origin='file:///tmp')
436
436
                ids = self.findEventIdsAndWait([template])
437
 
                self.assertEquals(ids, [4, 2, 3])
 
437
                self.assertEqual(ids, [4, 2, 3])
438
438
 
439
439
                # Now let's try with wildcard and negation
440
440
                template = Event.new_for_values(subject_current_origin='!file:*')
441
441
                ids = self.findEventIdsAndWait([template])
442
 
                self.assertEquals(map(int, ids), [5, 1])
 
442
                self.assertEqual(list(map(int, ids)), [5, 1])
443
443
 
444
444
                # Now let's try with wildcard and negation
445
445
                template = Event.new_for_values(subject_current_origin='!http:*')
446
446
                ids = self.findEventIdsAndWait([template])
447
 
                self.assertEquals(map(int, ids), [4, 2, 3])
 
447
                self.assertEqual(list(map(int, ids)), [4, 2, 3])
448
448
 
449
449
        def testFindEventIdsForSubjectStorage(self):
450
450
                # Retrieve events for a particular subject storage
451
451
                template = Event.new_for_values(subject_storage=
452
452
                        '368c991f-8b59-4018-8130-3ce0ec944157')
453
453
                ids = self.findEventIdsAndWait([template])
454
 
                self.assertEquals(ids, [4, 2, 3, 1])
 
454
                self.assertEqual(ids, [4, 2, 3, 1])
455
455
 
456
456
        def testFindEventIdsWithStorageState(self):
457
457
                """
463
463
                
464
464
                # Retrieve events with storage state "any"
465
465
                ids = self.findEventIdsAndWait([], storage_state=StorageState.Any)
466
 
                self.assertEquals(ids, [5, 4, 2, 3, 1])
 
466
                self.assertEqual(ids, [5, 4, 2, 3, 1])
467
467
                
468
468
                # Retrieve events with storage state "available"
469
469
                ids = self.findEventIdsAndWait([], storage_state=StorageState.Available)
470
 
                self.assertEquals(ids, [5, 4, 2, 3, 1])
 
470
                self.assertEqual(ids, [5, 4, 2, 3, 1])
471
471
                
472
472
                # Retrieve events with storage state "not available"
473
473
                ids = self.findEventIdsAndWait([],
474
474
                        storage_state=StorageState.NotAvailable)
475
 
                self.assertEquals(ids, [5, 4, 2, 3, 1])
 
475
                self.assertEqual(ids, [5, 4, 2, 3, 1])
476
476
 
477
477
        def testFindEventIdsWithUnknownStorageState(self):
478
478
                """
488
488
 
489
489
                tmpl = Event.new_for_values(subject_uri='file:///i-am-unknown')
490
490
                ids = self.findEventIdsAndWait([tmpl], storage_state=StorageState.Available)
491
 
                self.assertEquals(ids, [6])
 
491
                self.assertEqual(ids, [6])
492
492
 
493
493
class ZeitgeistRemoteInterfaceTest(testutils.RemoteTestCase):
494
494