def testDeleteNonExistantEvent(self):
# Insert an event (populate the database so it isn't empty)
events = parse_events("test/data/single_event.js")
ids = self.insertEventsAndWait(events)
# Try deleting a non-existant event
events = parse_events("test/data/single_event.js")
time_range = self.deleteEventsAndWait([int(ids[0]) + 1000])
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.assertEqual(1, len(retrieved_events))
self.assertEventsEqual(retrieved_events[0], events[0])
def testFindEventsId(self):
test_event_1 = parse_events("test/data/one_event.js")[0]
self.testSingleInsertGet()
result = self.findEventIdsAndWait([])
self.assertEqual(1, len(result))
test_event_1[0][0] = 1
self.assertEqual(result[0], test_event_1.id)
def testFindOneOfThreeEvents(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
self.assertEqual(3, len(ids))
events = self.getEventsAndWait(ids)
self.assertEqual(3, len(events))
for event in events:
self.assertTrue(isinstance(event, Event))
self.assertEqual(Manifestation.USER_ACTIVITY, event.manifestation)
self.assertTrue(event.actor.startswith("Boogaloo"))
# Search for everything
ids = self.findEventIdsAndWait([], num_events=3)
self.assertEqual(3, len(ids))
# Search for some specific templates
subj_templ1 = Subject.new_for_values(interpretation="!"+Interpretation.AUDIO)
subj_templ2 = Subject.new_for_values(interpretation="!"+Interpretation.IMAGE)
event_template = Event.new_for_values(
actor="Boogaloo*",
interpretation=Interpretation.ACCESS_EVENT,
subjects=[subj_templ1, subj_templ2])
ids = self.findEventIdsAndWait([event_template],
num_events=10)
self.assertEqual(1, len(ids))
events = self.getEventsAndWait(ids)
event = events[0]
self.assertEqual(event.subjects[0].interpretation, Interpretation.DOCUMENT)
def testMonitorReconnection(self):
result = []
mainloop = self.create_mainloop()
events = parse_events("test/data/three_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
result.extend(events)
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Unexpected delete notification")
self.client.install_monitor(TimeRange.always(), [],
notify_insert_handler, notify_delete_handler)
# Restart the Zeitgeist daemon to test automagic monitor re-connection
self.kill_daemon()
self.spawn_daemon()
# Insert events in idle loop to give the reconnection logic enough time
gobject.idle_add(lambda *args: self.client.insert_events(events))
mainloop.run()
self.assertEquals(3, len(result))
def testMonitorDeleteNonExistingEvent(self):
result = []
mainloop = self.create_mainloop(None)
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def timeout():
# We want this timeout - we should not get informed
# about deletions of non-existing events
mainloop.quit()
return False
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
event_ids = [ev.id for ev in events]
self.client.delete_events([9999999])
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Notified about deletion of non-existing events %s",
events)
self.client.install_monitor(TimeRange(125,
145), [], notify_insert_handler,
notify_delete_handler)
GLib.timeout_add_seconds(5, timeout)
self.client.insert_events(events)
mainloop.run()
def testMonitorReconnection(self):
result = []
mainloop = self.create_mainloop()
events = parse_events("test/data/three_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
result.extend(events)
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Unexpected delete notification")
self.client.install_monitor(TimeRange.always(), [],
notify_insert_handler,
notify_delete_handler)
# Restart the Zeitgeist daemon to test automagic monitor re-connection
self.kill_daemon()
self.spawn_daemon()
# Insert events in idle loop to give the reconnection logic enough time
GLib.idle_add(lambda *args: self.client.insert_events(events))
mainloop.run()
self.assertEqual(3, len(result))
def testFindEventsId(self):
test_event_1 = parse_events("test/data/one_event.js")[0]
self.testSingleInsertGet()
result = self.findEventIdsAndWait([])
self.assertEquals(1, len(result))
test_event_1[0][0] = 1
self.assertEqual(result[0], test_event_1.id)
def testMonitorDeleteNonExistingEvent(self):
result = []
mainloop = self.create_mainloop(None)
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def timeout():
# We want this timeout - we should not get informed
# about deletions of non-existing events
mainloop.quit()
return False
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
event_ids = map(lambda ev : ev.id, events)
self.client.delete_events([9999999])
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Notified about deletion of non-existing events %s", events)
self.client.install_monitor(TimeRange(125, 145), [],
notify_insert_handler, notify_delete_handler)
gobject.timeout_add_seconds(5, timeout)
self.client.insert_events(events)
mainloop.run()
def testFindEventsLimitWhenDuplicates(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
# This test makes sure that we get the requested number of events
# when some of them have multiple subjects (so more than one row
# with the same event id).
results = self.findEventsForTemplatesAndWait([], num_events=3)
self.assertEqual(3, len(results))
def testFindEventsWithMultipleSubjects(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
results = self.findEventsForTemplatesAndWait([], num_events=5)
self.assertEqual(3, len(results))
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 testInsertAndGetEvent(self):
# Insert an event
events = parse_events("test/data/single_event.js")
ids = self.insertEventsAndWait(events)
self.assertEqual(1, len(ids))
# Now get it back and check it hasn't changed
retrieved_events = self.getEventsAndWait(ids)
self.assertEqual(1, len(retrieved_events))
self.assertEventsEqual(retrieved_events[0], events[0])
def testFindWithActor(self):
test_event_1 = parse_events("test/data/one_event.js")[0]
self.testSingleInsertGet()
subj = Subject()
event_template = Event.new_for_values(
actor="application://gnome-about.desktop",
subjects=[subj,])
result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
self.assertEquals(1, len(result))
test_event_1[0][0] = 1
self.assertEqual(result[0], test_event_1.id)
def testFindWithActor(self):
test_event_1 = parse_events("test/data/one_event.js")[0]
self.testSingleInsertGet()
subj = Subject()
event_template = Event.new_for_values(
actor="application://gnome-about.desktop",
subjects=[subj,])
result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
self.assertEqual(1, len(result))
test_event_1[0][0] = 1
self.assertEqual(result[0], test_event_1.id)
def sanity_check(self):
events = self.findEventsForTemplatesAndWait([])
original_events = parse_events("test/data/upgrade_test.js")
# Ensure no events got lost (or duplicated)
self.assertEqual(len(events), len(original_events))
# Ensure no subjects got lost
for i in range(len(events)):
self.assertEqual(len(events[i].subjects),
len(original_events[i].subjects))
# Ensure data didn't change (unless it should)
for i in range(len(events)):
a = events[i]
b = original_events[i]
self.assertEqual(a.timestamp, b.timestamp)
self.assertEqual(a.interpretation, b.interpretation)
self.assertEqual(a.manifestation, b.manifestation)
self.assertEqual(a.actor, b.actor)
for j in range(len(a.subjects)):
sa = a.subjects[j]
sb = b.subjects[j]
self.assertEqual(sa.uri, sb.uri)
self.assertEqual(sa.interpretation, sb.interpretation)
if not sa.uri.startswith("http://"):
self.assertEqual(sa.manifestation, sb.manifestation)
self.assertEqual(sa.origin, sb.origin)
self.assertEqual(sa.mimetype, sb.mimetype)
self.assertEqual(sa.text, sb.text)
self.assertEqual(sa.storage, sb.storage)
# Introduced in Zeitgeist 0.8.0:
# - event.origin
# - subject.current_uri
for event in events:
self.assertEqual(event.origin, "")
for subject in event.subjects:
self.assertEqual(subject.current_uri, subject.uri)
# Introduced in Bluebird Alpha 2:
# - WebDataObject
for event in events:
for subject in event.subjects:
if subject.uri.startswith("http://"):
self.assertEqual(subject.manifestation,
Manifestation.WEB_DATA_OBJECT)
# Introduced in Zeitgeist 1.0 Beta 1
# - subject.current_origin
for event in events:
for subject in event.subjects:
self.assertEqual(subject.current_origin, subject.origin)
def sanity_check(self):
events = self.findEventsForTemplatesAndWait([])
original_events = parse_events("test/data/upgrade_test.js")
# Ensure no events got lost (or duplicated)
self.assertEquals(len(events), len(original_events))
# Ensure no subjects got lost
for i in range(len(events)):
self.assertEquals(len(events[i].subjects),
len(original_events[i].subjects))
# Ensure data didn't change (unless it should)
for i in range(len(events)):
a = events[i]
b = original_events[i]
self.assertEquals(a.timestamp, b.timestamp)
self.assertEquals(a.interpretation, b.interpretation)
self.assertEquals(a.manifestation, b.manifestation)
self.assertEquals(a.actor, b.actor)
for j in range(len(a.subjects)):
sa = a.subjects[j]
sb = b.subjects[j]
self.assertEquals(sa.uri, sb.uri)
self.assertEquals(sa.interpretation, sb.interpretation)
if not sa.uri.startswith("http://"):
self.assertEquals(sa.manifestation, sb.manifestation)
self.assertEquals(sa.origin, sb.origin)
self.assertEquals(sa.mimetype, sb.mimetype)
self.assertEquals(sa.text, sb.text)
self.assertEquals(sa.storage, sb.storage)
# Introduced in Zeitgeist 0.8.0:
# - event.origin
# - subject.current_uri
for event in events:
self.assertEquals(event.origin, "")
for subject in event.subjects:
self.assertEquals(subject.current_uri, subject.uri)
# Introduced in Bluebird Alpha 2:
# - WebDataObject
for event in events:
for subject in event.subjects:
if subject.uri.startswith("http://"):
self.assertEquals(subject.manifestation, Manifestation.WEB_DATA_OBJECT)
# Introduced in Zeitgeist 1.0 Beta 1
# - subject.current_origin
for event in events:
for subject in event.subjects:
self.assertEquals(subject.current_origin, subject.origin)
def testInsertAndDeleteEvent(self):
# Insert an event
events = parse_events("test/data/single_event.js")
ids = self.insertEventsAndWait(events)
# Delete it, make sure the returned time range is correct
time_range = self.deleteEventsAndWait(ids)
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.assertEqual(retrieved_events[0], None)
def testInsertWithEmptySubjectMimeType(self):
events = parse_events("test/data/incomplete_events.js")
ids = self.insertEventsAndWait([events[7]])
self.assertEqual(1, len(ids))
event = self.getEventsAndWait([ids[0]])[0]
self.assertEqual(1, len(event.subjects))
subject = event.subjects[0]
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 testIllegalPredefinedEventId(self):
event = parse_events("test/data/single_event.js")[0]
event[0][Event.Id] = "23" # This is illegal, we assert the error later
# Try inserting the event
ids = self.insertEventsAndWait([event,])
self.assertEquals(len(ids), 1)
# Event is not inserted, id == 0 means error
self.assertEquals(ids[0], 0)
# Ensure that it really wasn't inserted
ids = self.findEventIdsAndWait([])
self.assertEquals(len(ids), 0)
def testIllegalPredefinedEventId(self):
event = parse_events("test/data/single_event.js")[0]
event[0][Event.Id] = "23" # This is illegal, we assert the error later
# Try inserting the event
ids = self.insertEventsAndWait([event,])
self.assertEqual(len(ids), 1)
# Event is not inserted, id == 0 means error
self.assertEqual(ids[0], 0)
# Ensure that it really wasn't inserted
ids = self.findEventIdsAndWait([])
self.assertEqual(len(ids), 0)
def testDeleteTwoSimilarEvents(self):
# Insert a couple similar events
event1 = parse_events("test/data/single_event.js")[0]
event2 = Event(event1)
event2.timestamp = int(event1.timestamp) + 1
ids = self.insertEventsAndWait([event1, event2])
# Try deleting one of them
self.deleteEventsAndWait([ids[0]])
# Make sure it's gone, but the second one is still there
retrieved_events = self.getEventsAndWait(ids)
self.assertEqual(retrieved_events[0], None)
self.assertEventsEqual(retrieved_events[1], event2)
def testInsertIncompleteEvent(self):
events = parse_events("test/data/incomplete_events.js")
# Missing interpretation
ids = self.insertEventsAndWait([events[3]])
self.assertEqual(0, len(ids))
# Missing manifestation
ids = self.insertEventsAndWait([events[4]])
self.assertEqual(0, len(ids))
# Missing actor
ids = self.insertEventsAndWait([events[5]])
self.assertEqual(0, len(ids))
def testFindEventIdsWithUnknownStorageState(self):
"""
Events with storage state "unknown" should always be considered
as being available.
"""
event = parse_events("test/data/single_event.js")[0]
event.subjects[0].uri = 'file:///i-am-unknown'
event.subjects[0].storage = 'unknown'
self.insertEventsAndWait([event])
tmpl = Event.new_for_values(subject_uri='file:///i-am-unknown')
ids = self.findEventIdsAndWait([tmpl], storage_state=StorageState.Available)
self.assertEqual(ids, [6])
def testSingleInsertGet(self):
test_event_1 = parse_events("test/data/one_event.js")[0]
# Insert item and event
ids = self.insertEventsAndWait([test_event_1])
self.assertEqual(1, len(ids))
result = self.getEventsAndWait(ids)
resulting_event = result.pop()
self.assertEqual(len(resulting_event), len(test_event_1))
# fixing id, the initial event does not have any id set
test_event_1[0][0] = ids[0]
resulting_event[2] = ""
self.assertEqual(resulting_event, test_event_1)
def testSingleInsertGet(self):
test_event_1 = parse_events("test/data/one_event.js")[0]
# Insert item and event
ids = self.insertEventsAndWait([test_event_1])
self.assertEquals(1, len(ids))
result = self.getEventsAndWait(ids)
resulting_event = result.pop()
self.assertEquals(len(resulting_event), len(test_event_1))
# fixing id, the initial event does not have any id set
test_event_1[0][0] = ids[0]
resulting_event[2] = ""
self.assertEqual(resulting_event, test_event_1)
def testEventWithBinaryPayload(self):
event = parse_events("test/data/single_event.js")[0]
sampleString = """
<Content name="Telepathy" class="Text">
<header>[email protected]</header>
<body>
John: Here is a talking point
You: Ok that looks fine
</body>
<launcher command="{application} [email protected]"/>
</Content>"""
event.payload = sampleString.encode("utf-8")
ids = self.insertEventsAndWait([event])
result = self.getEventsAndWait(ids)[0]
result.payload = u"".join(unicode(x) for x in result.payload)
self.assertEquals(event.payload, result.payload)
self.assertEventsEqual(event, result)
def testEventWithBinaryPayload(self):
event = parse_events("test/data/single_event.js")[0]
sampleString = """
<Content name="Telepathy" class="Text">
<header>[email protected]</header>
<body>
John: 你好 Here is a talking point
You: Ok that looks fine
</body>
<launcher command="{application} [email protected]"/>
</Content>"""
event.payload = sampleString.encode("utf-8")
ids = self.insertEventsAndWait([event])
result = self.getEventsAndWait(ids)[0]
# verify all '248' bytes
self.assertEqual(len(event.payload), len(result.payload))
for i in list(range(len(event.payload))):
self.assertEqual(event.payload[i], result.payload[i])
def testInsertWithEmptySubjectInterpretationManifestation(self):
events = parse_events("test/data/incomplete_events.js")
ids = self.insertEventsAndWait(events[:3])
self.assertEqual(3, len(ids))
event = self.getEventsAndWait([ids[0]])[0]
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.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.assertEqual("something else", event.subjects[0].manifestation)
self.assertEqual("#Audio", event.subjects[0].interpretation)
def testMonitorInsertEvents(self):
result = []
mainloop = self.create_mainloop()
tmpl = Event.new_for_values(interpretation="stfu:OpenEvent")
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
result.extend(events)
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Unexpected delete notification")
self.client.install_monitor(TimeRange.always(), [tmpl],
notify_insert_handler, notify_delete_handler)
self.client.insert_events(events)
mainloop.run()
self.assertEquals(2, len(result))
def testMonitorDeleteEvents(self):
result = []
mainloop = self.create_mainloop()
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
event_ids = map(lambda ev : ev.id, events)
self.client.delete_events(event_ids)
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
result.extend(event_ids)
self.client.install_monitor(TimeRange(125, 145), [],
notify_insert_handler, notify_delete_handler)
self.client.insert_events(events)
mainloop.run()
self.assertEquals(2, len(result))
def testTwoMonitorsDeleteEvents(self):
result1 = []
result2 = []
mainloop = self.create_mainloop()
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def check_ok():
if len(result1) == 2 and len(result2) == 2:
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_insert_handler1(time_range, events):
event_ids = [ev.id for ev in events]
self.client.delete_events(event_ids)
@asyncTestMethod(mainloop)
def notify_delete_handler1(time_range, event_ids):
result1.extend(event_ids)
check_ok()
@asyncTestMethod(mainloop)
def notify_delete_handler2(time_range, event_ids):
result2.extend(event_ids)
check_ok()
self.client.install_monitor(TimeRange(125,
145), [], notify_insert_handler1,
notify_delete_handler1)
self.client.install_monitor(TimeRange(125, 145), [], lambda x, y: x,
notify_delete_handler2)
self.client.insert_events(events)
mainloop.run()
self.assertEqual(2, len(result1))
self.assertEqual(2, len(result2))
def testFindEventsWithNoexpandOperator(self):
events = parse_events("test/data/three_events.js")
ids = self.insertEventsAndWait(events)
template = Event.new_for_values(
subject_interpretation=Interpretation.MEDIA)
results = self.findEventsForTemplatesAndWait([template],
num_events=5)
self.assertEqual(3, len(results))
template = Event.new_for_values(
subject_interpretation='+%s' % Interpretation.MEDIA)
results = self.findEventsForTemplatesAndWait([template],
num_events=5)
self.assertEqual(0, len(results))
template = Event.new_for_values(
subject_interpretation='+%s' % Interpretation.AUDIO)
results = self.findEventsForTemplatesAndWait([template],
num_events=5)
self.assertEqual(1, len(results))
self.assertEqual(results[0].get_subjects()[0].interpretation,
Interpretation.AUDIO)
def testMonitorInsertEventsOutOfTimeRange(self):
result = []
mainloop = self.create_mainloop()
tmpl = Event.new_for_values(
subjects=[Subject.new_for_values(uri="file:///tmp/*")])
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
result.extend(events)
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Unexpected delete notification")
self.client.install_monitor([0,155], [tmpl],
notify_insert_handler, notify_delete_handler)
self.client.insert_events(events)
mainloop.run()
self.assertEquals(3, len(result))
def testMonitorDeleteEvents(self):
result = []
mainloop = self.create_mainloop()
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
event_ids = [ev.id for ev in events]
self.client.delete_events(event_ids)
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
result.extend(event_ids)
self.client.install_monitor(TimeRange(125,
145), [], notify_insert_handler,
notify_delete_handler)
self.client.insert_events(events)
mainloop.run()
self.assertEqual(2, len(result))
def testMonitorInsertEventsWithSubjectTemplate(self):
result = []
mainloop = self.create_mainloop()
tmpl = Event.new_for_values(
subjects=[Subject.new_for_values(uri="file:///tmp/bar.txt")])
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
result.extend(events)
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Unexpected delete notification")
self.client.install_monitor([153, 166], [tmpl], notify_insert_handler,
notify_delete_handler)
self.client.insert_events(events)
mainloop.run()
self.assertEqual(1, len(result))
def testMonitorInsertEvents(self):
result = []
mainloop = self.create_mainloop()
tmpl = Event.new_for_values(interpretation="stfu:OpenEvent")
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
result.extend(events)
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Unexpected delete notification")
self.client.install_monitor(TimeRange.always(), [tmpl],
notify_insert_handler,
notify_delete_handler)
self.client.insert_events(events)
mainloop.run()
self.assertEqual(2, len(result))
def testTwoMonitorsDeleteEvents(self):
result1 = []
result2 = []
mainloop = self.create_mainloop()
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def check_ok():
if len(result1) == 2 and len(result2) == 2:
mainloop.quit()
@asyncTestMethod(mainloop)
def notify_insert_handler1(time_range, events):
event_ids = map(lambda ev : ev.id, events)
self.client.delete_events(event_ids)
@asyncTestMethod(mainloop)
def notify_delete_handler1(time_range, event_ids):
result1.extend(event_ids)
check_ok()
@asyncTestMethod(mainloop)
def notify_delete_handler2(time_range, event_ids):
result2.extend(event_ids)
check_ok()
self.client.install_monitor(TimeRange(125, 145), [],
notify_insert_handler1, notify_delete_handler1)
self.client.install_monitor(TimeRange(125, 145), [],
lambda x, y: x, notify_delete_handler2)
self.client.insert_events(events)
mainloop.run()
self.assertEquals(2, len(result1))
self.assertEquals(2, len(result2))
def main():
if len(sys.argv) != 2:
raise SystemExit, 'Usage: %s <json file>' % sys.argv[0]
events = parse_events(sys.argv[1])
insert_events(events)
def testGetEvents(self):
events = parse_events("test/data/five_events.js")
ids = self.insertEventsAndWait(events) + [1000, 2000]
result = self.getEventsAndWait(ids)
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 testUnicodeInsert(self):
events = parse_events("test/data/unicode_event.js")
ids = self.insertEventsAndWait(events)
self.assertEqual(len(ids), len(events))
result_events = self.getEventsAndWait(ids)
self.assertEqual(len(ids), len(result_events))
def main():
if len(sys.argv) != 2:
raise SystemExit, 'Usage: %s <json file>' % sys.argv[0]
events = parse_events(sys.argv[1])
insert_events(events)
def setUp(self):
super(ZeitgeistRemoteFindEventIdsTest, self).setUp()
# Insert some events...
events = parse_events("test/data/five_events.js")
self.ids = self.insertEventsAndWait(events)
def testInsertIncompleteSubject(self):
events = parse_events("test/data/incomplete_events.js")
# Missing one subject URI
ids = self.insertEventsAndWait([events[6]])
self.assertEqual(0, len(ids))
