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 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))