def testSortFindByTimeDesc(self):
import_events("test/data/twenty_events.js", self)
result = self.findEventIdsAndWait([], num_events=2,
result_type=ResultType.MostRecentEvents)
event1 = self.getEventsAndWait([result[0]])[0]
event2 = self.getEventsAndWait([result[1]])[0]
self.assertEqual(True, event1.timestamp > event2.timestamp)
def testFindFiveWithStorageState(self):
import_events("test/data/five_events.js", self)
# The event's storage is unknown, so we get them back always.
result = self.findEventIdsAndWait([], storage_state=1)
self.assertEqual(5, len(result))
result = self.findEventIdsAndWait([], storage_state=0)
self.assertEqual(5, len(result))
def testFindFiveWithStorageState(self):
import_events("test/data/five_events.js", self)
# The event's storage is unknown, so we get them back always.
result = self.findEventIdsAndWait([], storage_state=1)
self.assertEquals(5, len(result))
result = self.findEventIdsAndWait([], storage_state=0)
self.assertEquals(5, len(result))
def testFindEventTwoInterpretations(self):
import_events("test/data/twenty_events.js", self)
result = self.findEventIdsAndWait([
Event.new_for_values(interpretation="stfu:OpenEvent"),
Event.new_for_values(interpretation="stfu:EvilEvent")],
timerange = (102, 117), num_events=0, result_type=0)
self.assertEqual(15, len(result))
def testMoving(self):
import_events("test/data/five_events.js", self)
import_events("test/data/five_events_ext_move.js", self)
template = Event.new_for_values(subject_current_uri='file:///*')
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentCurrentUri)
self.assertEqual(2, len(ids))
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentCurrentUri)
self.assertEqual(2, len(ids))
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentEvents)
self.assertEqual(5, len(ids))
template = Event.new_for_values(subject_current_origin='file:///*')
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentEvents)
self.assertEqual(4, len(ids))
def testMoving(self):
import_events("test/data/five_events.js", self)
import_events("test/data/five_events_ext_move.js", self)
template = Event.new_for_values(subject_current_uri='file:///*')
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentCurrentUri)
self.assertEquals(2, len(ids))
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentCurrentUri)
self.assertEquals(2, len(ids))
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentEvents)
self.assertEquals(5, len(ids))
template = Event.new_for_values(subject_current_origin='file:///*')
ids = self.findEventIdsAndWait([template],
num_events = 0,
result_type = ResultType.MostRecentEvents)
self.assertEquals(4, len(ids))
def testSortFindByTimeDesc(self):
import_events("test/data/twenty_events.js", self)
result = self.findEventIdsAndWait([], num_events=2,
result_type=ResultType.MostRecentEvents)
event1 = self.getEventsAndWait([result[0]])[0]
event2 = self.getEventsAndWait([result[1]])[0]
self.assertEquals(True, event1.timestamp > event2.timestamp)
def testFindEventTwoInterpretations(self):
import_events("test/data/twenty_events.js", self)
result = self.findEventIdsAndWait([
Event.new_for_values(interpretation="stfu:OpenEvent"),
Event.new_for_values(interpretation="stfu:EvilEvent")],
timerange = (102, 117), num_events=0, result_type=0)
self.assertEquals(15, len(result))
def testResultTypesLeastRecentSubjectOrigin(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastRecentOrigin)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events], ["116", "118", "119"])
def testResultTypesMostPopularSubject(self):
import_events("test/data/five_events.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.MostPopularSubjects)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events],
["143", "163", "153", "123"])
def testResultTypesLeastPopularCurrentUri(self):
import_events("test/data/five_events.js", self)
import_events("test/data/five_events_ext_move.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastPopularCurrentUri)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events], ["153", "123", "200"])
def testFindWithEventOriginNegatedWildcard(self):
import_events("test/data/twenty_events.js", self)
event_template = Event.new_for_values(origin="!origin*")
result = self.findEventIdsAndWait([event_template],
num_events=0, result_type=1)
events = self.getEventsAndWait(result)
self.assertTrue(len(events) > 0)
self.assertFalse(any(ev.origin.startswith("origin") for ev in events))
def testFindWithEventOrigin(self):
import_events("test/data/twenty_events.js", self)
event_template = Event.new_for_values(origin="origin3")
result = self.findEventIdsAndWait([event_template],
num_events=0, result_type=1)
events = self.getEventsAndWait(result)
self.assertTrue(len(events) > 0)
self.assertTrue(all(ev.origin == "origin3" for ev in events))
def testResultTypesMostRecentActor(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait([],
num_events=0,
result_type=ResultType.MostRecentActor)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events], ["119", "114", "105"])
def testResultTypesOldestActor(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[Event.new_for_values(subject_manifestation="stfu:File")],
num_events=0,
result_type=ResultType.OldestActor)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events], ["100", "101", "105"])
def testFindWithInterpretation(self):
import_events("test/data/five_events.js", self)
subj = Subject()
event_template = Event.new_for_values(interpretation="stfu:OpenEvent", subjects=[subj])
result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
self.assertEqual(2, len(result))
events = self.getEventsAndWait(result)
for event in events:
self.assertEqual(event.interpretation, "stfu:OpenEvent")
def testFindMultipleEvents(self):
import_events("test/data/five_events.js", self)
subj1 = Subject.new_for_values(uri="file:///home/foo.txt")
event_template1 = Event.new_for_values(subjects=[subj1])
subj2 = Subject.new_for_values(uri="file:///tmp/foo.txt")
event_template2 = Event.new_for_values(subjects=[subj2])
result = self.findEventIdsAndWait([event_template1, event_template2], num_events=0, result_type=4)
self.assertEquals(2, len(result))
events = self.getEventsAndWait(result)
def testFindWithSubjectOrigin(self):
import_events("test/data/five_events.js", self)
subj = Subject.new_for_values(origin="file:///tmp")
event_template = Event.new_for_values(subjects=[subj])
result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
events = self.getEventsAndWait(result)
for event in events:
test = any(subj.origin == "file:///tmp" for subj in event.subjects)
self.assertTrue(test)
def testResultTypesLeastPopularMimeType(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastPopularMimeType)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events],
['114', '107', '110', '119'])
def testFindWithEventOriginNegatedWildcard(self):
import_events("test/data/twenty_events.js", self)
event_template = Event.new_for_values(origin="!origin*")
result = self.findEventIdsAndWait([event_template],
num_events=0, result_type=1)
events = self.getEventsAndWait(result)
self.assertTrue(len(events) > 0)
self.assertFalse(any(ev.origin.startswith("origin") for ev in events))
def testFindWithSubjectOrigin(self):
import_events("test/data/five_events.js", self)
subj = Subject.new_for_values(origin="file:///tmp")
event_template = Event.new_for_values(subjects=[subj])
result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
events = self.getEventsAndWait(result)
for event in events:
test = any(subj.origin == "file:///tmp" for subj in event.subjects)
self.assertTrue(test)
def testFindWithEventOrigin(self):
import_events("test/data/twenty_events.js", self)
event_template = Event.new_for_values(origin="origin3")
result = self.findEventIdsAndWait([event_template],
num_events=0, result_type=1)
events = self.getEventsAndWait(result)
self.assertTrue(len(events) > 0)
self.assertTrue(all(ev.origin == "origin3" for ev in events))
def testFindMultipleEvents(self):
import_events("test/data/five_events.js", self)
subj1 = Subject.new_for_values(uri="file:///home/foo.txt")
event_template1 = Event.new_for_values(subjects=[subj1])
subj2 = Subject.new_for_values(uri="file:///tmp/foo.txt")
event_template2 = Event.new_for_values(subjects=[subj2])
result = self.findEventIdsAndWait([event_template1, event_template2], num_events=0, result_type=4)
self.assertEqual(2, len(result))
events = self.getEventsAndWait(result)
def testFindWithInterpretation(self):
import_events("test/data/five_events.js", self)
subj = Subject()
event_template = Event.new_for_values(interpretation="stfu:OpenEvent", subjects=[subj])
result = self.findEventIdsAndWait([event_template], num_events=0, result_type=1)
self.assertEquals(2, len(result))
events = self.getEventsAndWait(result)
for event in events:
self.assertEqual(event.interpretation, "stfu:OpenEvent")
def testWildcard(self):
import_events("test/data/five_events.js", self)
template = Event.new_for_values(
actor = "ge*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(2, len(ids))
template = Event.new_for_values(
actor = "!ge*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(3, len(ids))
template = Event.new_for_values(
subject_mimetype = "text/*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(3, len(ids))
template = Event.new_for_values(
subject_uri = "http://*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(1, len(ids))
template = Event.new_for_values(
subject_current_uri = "http://*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(1, len(ids))
template = Event.new_for_values(
subject_origin = "file://*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(3, len(ids))
def testWildcard(self):
import_events("test/data/five_events.js", self)
template = Event.new_for_values(
actor = "ge*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(2, len(ids))
template = Event.new_for_values(
actor = "!ge*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(3, len(ids))
template = Event.new_for_values(
subject_mimetype = "text/*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(3, len(ids))
template = Event.new_for_values(
subject_uri = "http://*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(1, len(ids))
template = Event.new_for_values(
subject_current_uri = "http://*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(1, len(ids))
template = Event.new_for_values(
subject_origin = "file://*"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(3, len(ids))
def testResultTypesMostRecentCurrentOrigin(self):
import_events("test/data/five_events.js", self)
import_events("test/data/five_events_ext_move.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.MostRecentCurrentOrigin)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events],
["200", "163", "153", "123"])
def testFindWithSubjectText(self):
import_events("test/data/five_events.js", self)
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this is not real')])
self.assertEquals(0, len(result))
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='some text')])
self.assertEquals(1, len(result))
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this *')])
self.assertEquals(0, len(result)) # We don't support wildcards for text
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this item *')])
self.assertEquals(1, len(result))
def testResultTypesLeastPopularEventOrigin(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastPopularEventOrigin)
events = self.getEventsAndWait(ids)
self.assertEqual([e[0][5] for e in events],
["origin2", "origin3", "origin1"])
self.assertEqual([e.timestamp for e in events], ["100", "103", "102"])
def testResultTypesLeastPopularSubjectOrigin(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastPopularOrigin)
events = self.getEventsAndWait(ids)
self.assertEqual([e[1][0][3] for e in events],
["file:///etc", "file:///home", "file:///tmp"])
self.assertEqual([e.timestamp for e in events], ["119", "118", "116"])
def testResultTypesLeastPopularActor(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastPopularActor)
events = self.getEventsAndWait(ids)
self.assertEqual([e[0][4] for e in events],
["frobnicator", "icedove", "firefox"])
self.assertEqual([e.timestamp for e in events], ["105", "114", "119"])
def testFindWithSubjectText(self):
import_events("test/data/five_events.js", self)
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this is not real')])
self.assertEqual(0, len(result))
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='some text')])
self.assertEqual(1, len(result))
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this *')])
self.assertEqual(0, len(result)) # We don't support wildcards for text
result = self.findEventIdsAndWait([Event.new_for_values(subject_text='this item *')])
self.assertEqual(1, len(result))
def testResultTypesLeastRecentEvents(self):
import_events("test/data/five_events.js", self)
# LeastRecentEvents - old -> new
ids = self.findEventIdsAndWait(
[], num_events=0, result_type=ResultType.LeastRecentEvents)
events = self.getEventsAndWait(ids)
sorted_event_ids = [
event.id for event in sorted(events, key=lambda x: x.timestamp)
]
self.assertEqual(list(ids), sorted_event_ids)
def testResultTypesLeastPopularSubjectInterpretation(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait(
[],
num_events=0,
result_type=ResultType.LeastPopularSubjectInterpretation)
events = self.getEventsAndWait(ids)
self.assertEqual([e.timestamp for e in events],
['118', '106', '116', '119'])
def testFindWithManifestation(self):
import_events("test/data/five_events.js", self)
subj = Subject()
event_template = Event.new_for_values(manifestation="stfu:EpicFailActivity", subjects=[subj])
result = self.findEventIdsAndWait([event_template],
num_events=0, result_type=1)
self.assertEquals(1, len(result))
events = self.getEventsAndWait(result)
for event in events:
self.assertEqual(event.manifestation, "stfu:EpicFailActivity")
def testResultTypesMostPopularActor2(self):
import_events("test/data/twenty_events.js", self)
ids = self.findEventIdsAndWait([],
timerange=(105, 107),
num_events=0,
result_type=ResultType.MostPopularActor)
events = self.getEventsAndWait(ids)
self.assertEqual(len(events), 2)
self.assertEqual([e[0][4] for e in events], ["firefox", "frobnicator"])
self.assertEqual([e.timestamp for e in events], ["107", "105"])
def testFindWithManifestation(self):
import_events("test/data/five_events.js", self)
subj = Subject()
event_template = Event.new_for_values(manifestation="stfu:EpicFailActivity", subjects=[subj])
result = self.findEventIdsAndWait([event_template],
num_events=0, result_type=1)
self.assertEqual(1, len(result))
events = self.getEventsAndWait(result)
for event in events:
self.assertEqual(event.manifestation, "stfu:EpicFailActivity")
def testUnicodeEventInsert(self):
# Insert and get a unicode event
ids = import_events("test/data/unicode_event.js", self)
self.assertEqual(len(ids), 1)
result = self.getEventsAndWait(ids)
self.assertEqual(1, len(result))
event = result[0]
self.assertEqual(1, len(event.subjects))
self.assertEqual("hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
self.assertEqual("http://live.gnome.org/☠", event.subjects[0].uri)
# Update the event we got from the DB's timestamp and insert
# it again, we want to to test some ping-pong back and forth
event[0][Event.Id] = ""
event.timestamp = "243"
ids = self.insertEventsAndWait([event])
result = self.getEventsAndWait(ids)
self.assertEqual(1, len(result))
event = result[0]
self.assertEqual(1, len(event.subjects))
self.assertEqual("hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
self.assertEqual("http://live.gnome.org/☠", event.subjects[0].uri)
# Try and find a unicode event
subj = Subject.new_for_values(text="hällö, I'm gürmen - åge drikker øl - ☠",
origin="file:///åges_øl í", uri="http://live.gnome.org/☠")
event_template = Event.new_for_values(subjects=[subj,])
result = self.findEventIdsAndWait([event_template],
timerange=(0,200), num_events=100, result_type=0)
self.assertEqual(len(result), 1)
def testUnicodeEventInsert(self):
# Insert and get a unicode event
ids = import_events("test/data/unicode_event.js", self)
self.assertEquals(len(ids), 1)
result = self.getEventsAndWait(ids)
self.assertEquals(1, len(result))
event = result[0]
self.assertEquals(1, len(event.subjects))
self.assertEquals(u"hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
self.assertEquals(u"http://live.gnome.org/☠", event.subjects[0].uri)
# Update the event we got from the DB's timestamp and insert
# it again, we want to to test some ping-pong back and forth
event[0][Event.Id] = ""
event.timestamp = "243"
ids = self.insertEventsAndWait([event])
result = self.getEventsAndWait(ids)
self.assertEquals(1, len(result))
event = result[0]
self.assertEquals(1, len(event.subjects))
self.assertEquals(u"hällö, I'm gürmen - åge drikker øl - ☠", event.subjects[0].text)
self.assertEquals(u"http://live.gnome.org/☠", event.subjects[0].uri)
# Try and find a unicode event
subj = Subject.new_for_values(text="hällö, I'm gürmen - åge drikker øl - ☠",
origin="file:///åges_øl í", uri=u"http://live.gnome.org/☠")
event_template = Event.new_for_values(subjects=[subj,])
result = self.findEventIdsAndWait([event_template],
timerange=(0,200), num_events=100, result_type=0)
self.assertEquals(len(result), 1)
def testGetDuplicateEventIds(self):
ids = import_events("test/data/five_events.js", self)
self.assertEqual(5, len(ids))
events = self.getEventsAndWait([1, 1])
self.assertEqual(2, len(events))
self.assertEqual(2, len([_f for _f in events if _f]))
self.assertTrue(events[0].id == events[1].id == 1)
def testGetDuplicateEventIds(self):
ids = import_events("test/data/five_events.js", self)
self.assertEquals(5, len(ids))
events = self.getEventsAndWait([1, 1])
self.assertEqual(2, len(events))
self.assertEqual(2, len(filter(None, events)))
self.assertTrue(events[0].id == events[1].id == 1)
def testJsonImport(self):
import_events("test/data/single_event.js", self)
results = self.getEventsAndWait([1])
self.assertEqual(1, len(results))
ev = results[0]
self.assertEqual(1, ev.id)
self.assertEqual("123", ev.timestamp)
self.assertEqual("stfu:OpenEvent", ev.interpretation)
self.assertEqual("stfu:UserActivity", ev.manifestation)
self.assertEqual("firefox", ev.actor)
self.assertEqual(1, len(ev.subjects))
subj = ev.subjects[0]
self.assertEqual("file:///tmp/foo.txt", subj.uri)
self.assertEqual("stfu:Document", subj.interpretation)
self.assertEqual("stfu:File", subj.manifestation)
self.assertEqual("text/plain", subj.mimetype)
self.assertEqual("this item has no text... rly!", subj.text)
self.assertEqual("368c991f-8b59-4018-8130-3ce0ec944157", subj.storage)
def testJsonImport(self):
import_events("test/data/single_event.js", self)
results = self.getEventsAndWait([1])
self.assertEquals(1, len(results))
ev = results[0]
self.assertEquals(1, ev.id)
self.assertEquals("123", ev.timestamp)
self.assertEquals("stfu:OpenEvent", ev.interpretation)
self.assertEquals("stfu:UserActivity", ev.manifestation)
self.assertEquals("firefox", ev.actor)
self.assertEquals(1, len(ev.subjects))
subj = ev.subjects[0]
self.assertEquals("file:///tmp/foo.txt", subj.uri)
self.assertEquals("stfu:Document", subj.interpretation)
self.assertEquals("stfu:File", subj.manifestation)
self.assertEquals("text/plain", subj.mimetype)
self.assertEquals("this item has no text... rly!", subj.text)
self.assertEquals("368c991f-8b59-4018-8130-3ce0ec944157", subj.storage)
def testFindEventsEventTemplate(self):
import_events("test/data/five_events.js", self)
subj = Subject.new_for_values(interpretation="stfu:Bee")
subj1 = Subject.new_for_values(interpretation="stfu:Bar")
event_template = Event.new_for_values(subjects=[subj, subj1])
result = self.findEventIdsAndWait(
[event_template, ],
timerange = (0, 200),
num_events=100,
result_type=0)
self.assertEquals(0, len(result)) # no subject with two different
# interpretations at the same time
subj = Subject.new_for_values(uri="file:///tmp/foo.txt")
subj1 = Subject.new_for_values(interpretation="stfu:Image")
event_template = Event.new_for_values(subjects=[subj, subj1])
result = self.findEventIdsAndWait(
[event_template, ],
timerange = (0, 200),
num_events=100,
result_type=0)
self.assertEquals(1, len(result))
def testFindEventsEventTemplate(self):
import_events("test/data/five_events.js", self)
subj = Subject.new_for_values(interpretation="stfu:Bee")
subj1 = Subject.new_for_values(interpretation="stfu:Bar")
event_template = Event.new_for_values(subjects=[subj, subj1])
result = self.findEventIdsAndWait(
[event_template, ],
timerange = (0, 200),
num_events=100,
result_type=0)
self.assertEqual(0, len(result)) # no subject with two different
# interpretations at the same time
subj = Subject.new_for_values(uri="file:///tmp/foo.txt")
subj1 = Subject.new_for_values(interpretation="stfu:Image")
event_template = Event.new_for_values(subjects=[subj, subj1])
result = self.findEventIdsAndWait(
[event_template, ],
timerange = (0, 200),
num_events=100,
result_type=0)
self.assertEqual(1, len(result))
def testNegationCombination(self):
import_events("test/data/five_events.js", self)
template = Event.new_for_values(
interpretation = "!stfu:OpenEvent",
actor = "!firefox"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(2, len(ids))
template = Event.new_for_values(
interpretation = "!stfu:OpenEvent",
manifestation = "!stfu:YourActivity"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEqual(3, len(ids))
def testNegationCombination(self):
import_events("test/data/five_events.js", self)
template = Event.new_for_values(
interpretation = "!stfu:OpenEvent",
actor = "!firefox"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(2, len(ids))
template = Event.new_for_values(
interpretation = "!stfu:OpenEvent",
manifestation = "!stfu:YourActivity"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(3, len(ids))
def testFindWithFakeInterpretation(self):
import_events("test/data/twenty_events.js", self)
result = self.findEventIdsAndWait([Event.new_for_values(
interpretation="this-is-not-an-interpretation")])
self.assertEquals(0, len(result))
def testNegation(self):
import_events("test/data/five_events.js", self)
template = Event.new_for_values(
interpretation = "!stfu:OpenEvent"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(3, len(ids))
template = Event.new_for_values(
manifestation = "!stfu:YourActivity"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(4, len(ids))
template = Event.new_for_values(
actor = "!firefox"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(2, len(ids))
template = Event.new_for_values(
subject_uri = "!file:///tmp/foo.txt"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(3, len(ids))
template = Event.new_for_values(
subject_interpretation = "!stfu:Document"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(4, len(ids))
template = Event.new_for_values(
subject_manifestation = "!stfu:File"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(1, len(ids))
template = Event.new_for_values(
subject_origin = "!file:///tmp"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(2, len(ids))
template = Event.new_for_values(
subject_mimetype = "!text/plain"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(2, len(ids))
# the next two fields do not support negation, '!' is treated as
# content
template = Event.new_for_values(
subject_text = "!boo"
)
ids = self.findEventIdsAndWait([template,],
num_events=10,
result_type=ResultType.MostRecentEvents
)
self.assertEquals(0, len(ids))
def testFindFive(self):
import_events("test/data/five_events.js", self)
result = self.findEventIdsAndWait([])
self.assertEquals(5, len(result))
def testFindWithNonExistantActor(self):
# Bug 496109: filtering by timerange and a non-existing actor gave an
# incorrect result.
import_events("test/data/twenty_events.js", self)
result = self.findEventIdsAndWait([Event.new_for_values(actor="fake://foobar")])
self.assertEquals(0, len(result))
