def setUpRouter(self): Trace("setUp","TestEventPubSub") a = MyEventHandler("A") b = MyEventHandler("B") c = MyEventHandler("C") d = MyEventHandler("D") e = MyEventHandler("E") f = MyEventHandler("F") g = MyEventHandler("G") h = MyEventHandler("H") self.handlers = (a, b, c, d, e, f, g, h) self.router = EventPubSub(uri="LocalRouter") self.router.subscribe(60, a, evtype="t1", source="s1") self.router.subscribe(60, b, evtype="t2", source="s1") self.router.subscribe(60, c, evtype="t1", source="s2") self.router.subscribe(60, d, evtype="t2", source="s2") self.router.subscribe(60, e, evtype="t1") self.router.subscribe(60, f, evtype="", source="s1") self.router.subscribe(60, g, source="") self.router.subscribe(60, h, evtype="t2", source="s1") # same as b Trace("setUp exit","TestEventPubSub") return
class TestEventPubSub(unittest.TestCase): def setUpRouter(self): Trace("setUp","TestEventPubSub") a = MyEventHandler("A") b = MyEventHandler("B") c = MyEventHandler("C") d = MyEventHandler("D") e = MyEventHandler("E") f = MyEventHandler("F") g = MyEventHandler("G") h = MyEventHandler("H") self.handlers = (a, b, c, d, e, f, g, h) self.router = EventPubSub(uri="LocalRouter") self.router.subscribe(60, a, evtype="t1", source="s1") self.router.subscribe(60, b, evtype="t2", source="s1") self.router.subscribe(60, c, evtype="t1", source="s2") self.router.subscribe(60, d, evtype="t2", source="s2") self.router.subscribe(60, e, evtype="t1") self.router.subscribe(60, f, evtype="", source="s1") self.router.subscribe(60, g, source="") self.router.subscribe(60, h, evtype="t2", source="s1") # same as b Trace("setUp exit","TestEventPubSub") return def setUp(self): self.a = None self.b = None self.c = None self.d = None self.e = None self.f = None self.g = None self.h = None return def tearDown(self): Trace("tearDown","TestEventPubSub") if self.a: self.router.unsubscribe(self.a, evtype="t1", source="s1") if self.b: self.router.unsubscribe(self.b, evtype="t2", source="s1") if self.c: self.router.unsubscribe(self.c, evtype="t1", source="s2") if self.d: self.router.unsubscribe(self.d, evtype="t2", source="s2") if self.e: self.router.unsubscribe(self.e, evtype="t1") if self.f: self.router.unsubscribe(self.f, source="s1") if self.g: self.router.unsubscribe(self.g) if self.h: self.router.unsubscribe(self.h, evtype="t2", source="s1") Trace("tearDown exit","TestEventPubSub") return def doTestPublish(self,typid,srcid,expectTriggered): src = makeEventAgent(typid+srcid) evt = makeEvent(evtype=typid,source=srcid) sts = self.router.publish(src, evt) self.assertEqual( sts.syncValue(), StatusVal.OK, str(sts.syncValue())+" is not StatusVal.OK" ) mapAssert(evTriggerEq, self.handlers, expectTriggered, "Trigger "+typid+srcid) return # Test cases # Test basic Wil;dDict functions def testWildDict1(self): Trace("testWildDict1","TestEventPubSub") wd = WildDict() # Basic insertion tests self.assertEqual(wd.find("a"), []) self.assertEqual(wd.find("b"), []) wd.insert("a","A1") wd.insert(None,"N1") self.assertEqual(wd.find("a"), ["A1","N1"]) self.assertEqual(wd.find("b"), ["N1"]) wd.insert("a","A2") wd.insert("b","B1") wd.insert("b","B2") wd.insert(None,"N2") self.assertEqual(wd.find("a"), ["A1","A2","N1","N2"]) self.assertEqual(wd.find("b"), ["B1","B2","N1","N2"]) # Scan contents kvs = [("a","A1"), ("a","A2"), ("b","B1"), ("b","B2"), (None,"N1"), (None,"N2")] self.assertEqual(list(wd.iterateAll()), kvs) self.assertEqual(wd.count(), 6) # Basic removal tests b1 = wd.remove("b","B1") self.assertEqual(b1, ["B1"]) self.assertEqual(wd.find("b"), ["B2","N1","N2"]) b2 = wd.remove("b","B2") self.assertEqual(b2, ["B2"]) self.assertEqual(wd.find("b"), ["N1","N2"]) n2 = wd.remove(None,"N2") self.assertEqual(n2, ["N2"]) self.assertEqual(wd.find("a"), ["A1","A2","N1"]) self.assertEqual(wd.find("b"), ["N1"]) n1 = wd.remove(None,"N1") self.assertEqual(n1, ["N1"]) self.assertEqual(wd.find("a"), ["A1","A2"]) self.assertEqual(wd.find("b"), []) # Multiple-value insertion tests wd.insert("c","C") wd.insert(None,"N") wd.insert("c","C") wd.insert(None,"N") self.assertEqual(wd.find("c"), ["C","C","N","N"]) # Multiple-value removal tests el = wd.remove("c","C1") self.assertEqual(el, []) self.assertEqual(wd.find("c"), ["C","C","N","N"]) cc = wd.remove("c","C") self.assertEqual(cc, ["C","C"]) self.assertEqual(wd.find("c"), ["N","N"]) el = wd.remove("c","C") self.assertEqual(el, []) self.assertEqual(wd.find("c"), ["N","N"]) el = wd.remove(None,"C") self.assertEqual(el, []) self.assertEqual(wd.find("c"), ["N","N"]) nn = wd.remove(None,"N") self.assertEqual(nn, ["N","N"]) self.assertEqual(wd.find("c"), []) el = wd.remove(None,"N") self.assertEqual(el, []) self.assertEqual(wd.find("a"), ["A1","A2"]) self.assertEqual(wd.find("b"), []) self.assertEqual(wd.find("c"), []) return # Additional WildDict test for special wildcard-matching search def testWildDict2(self): Trace("testWildDict1","TestEventPubSub") # Create and test dictionary wd = WildDict() kvs = [("a","A1"), ("a","A2"), ("b","B1"), ("b","B2"), (None,"N1"), (None,"N2")] for (k,v) in kvs: wd.insert(k,v) self.assertEqual(list(wd.iterateAll()), kvs) self.assertEqual(wd.count(), 6) # Now test iterateWild functions self.assertEqual(list(wd.iterateWild(None)), kvs) self.assertEqual(list(wd.iterateWild("a")), [("a","A1"), ("a","A2"), (None,"N1"), (None,"N2")]) self.assertEqual(list(wd.iterateWild("b")), [("b","B1"), ("b","B2"), (None,"N1"), (None,"N2")]) self.assertEqual(list(wd.iterateWild("c")), [(None,"N1"), (None,"N2")]) return # Additional WildDict test for iteration logic def testWildDictIterate(self): Trace("testWildDictIterate","TestEventPubSub") wd = WildDict() wd.insert("a","A1") wd.insert(None,"N1") wd.insert("","N2") # Blank is also a wildcard like None cnt1 = 0 for entry in wd.iterate("a"): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 3) cnt1 = 0 for entry in wd.iterate(""): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 2) cnt1 = 0 for entry in wd.iterate(None): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 2) # Test basic event+source keyed dictionary functions def testEventTypeSourceDict1(self): Trace("testEventTypeSourceDict1","TestEventPubSub") ed = EventTypeSourceDict() # Basic insertion tests self.assertEqual(ed.find("at","as"), []) self.assertEqual(ed.find("bt","bs"), []) ed.insert("at","as","A1") ed.insert(None,None,"N1") self.assertEqual(ed.find("at","as"), ["A1","N1"]) self.assertEqual(ed.find("bt","bs"), ["N1"]) ed.insert("at","as","A2") ed.insert("bt","bs","B1") ed.insert("bt","bs","B2") ed.insert(None,None,"N2") self.assertEqual(ed.find("at","as"), ["A1","A2","N1","N2"]) self.assertEqual(ed.find("bt","bs"), ["B1","B2","N1","N2"]) # Scan contents tsvs = [ ("bt","bs","B1"), ("bt","bs","B2") , ("at","as","A1"), ("at","as","A2") , (None,None,"N1"), (None,None,"N2") ] self.assertEqual(list(ed.iterateAll()), tsvs) self.assertEqual(ed.count(), 6) # Basic removal tests b1 = ed.remove("bt","bs","B1") self.assertEqual(b1, ["B1"]) self.assertEqual(ed.find("bt","bs"), ["B2","N1","N2"]) b2 = ed.remove("bt","bs","B2") self.assertEqual(b2, ["B2"]) self.assertEqual(ed.find("bt","bs"), ["N1","N2"]) n2 = ed.remove(None,None,"N2") self.assertEqual(n2, ["N2"]) self.assertEqual(ed.find("at","as"), ["A1","A2","N1"]) self.assertEqual(ed.find("bt","bs"), ["N1"]) n1 = ed.remove(None,None,"N1") self.assertEqual(n1, ["N1"]) self.assertEqual(ed.find("at","as"), ["A1","A2"]) self.assertEqual(ed.find("bt","bs"), []) # Scan contents tsvs = [ ("at","as","A1"), ("at","as","A2") ] self.assertEqual(list(ed.iterateAll()), tsvs) self.assertEqual(ed.count(), 2) # Multiple-value insertion tests ed.insert("ct","cs","C") ed.insert(None,None,"N") ed.insert("ct","cs","C") ed.insert(None,None,"N") self.assertEqual(ed.find("ct","cs"), ["C","C","N","N"]) # Scan contents tsvs = [ ("at","as","A1"), ("at","as","A2") , ("ct","cs","C"), ("ct","cs","C") , (None,None,"N"), (None,None,"N") ] self.assertEqual(list(ed.iterateAll()), tsvs) self.assertEqual(ed.count(), 6) # Multiple-value removal tests el = ed.remove("ct","cs","C1") self.assertEqual(el, []) self.assertEqual(ed.find("ct","cs"), ["C","C","N","N"]) cc = ed.remove("ct","cs","C") self.assertEqual(cc, ["C","C"]) self.assertEqual(ed.find("ct","cs"), ["N","N"]) el = ed.remove("ct","cs","C") self.assertEqual(el, []) self.assertEqual(ed.find("ct","cs"), ["N","N"]) el = ed.remove(None,None,"C") self.assertEqual(el, []) self.assertEqual(ed.find("ct","cs"), ["N","N"]) nn = ed.remove(None,None,"N") self.assertEqual(nn, ["N","N"]) self.assertEqual(ed.find("ct","cs"), []) el = ed.remove(None,None,"N") self.assertEqual(el, []) self.assertEqual(ed.find("at","as"), ["A1","A2"]) self.assertEqual(ed.find("bt","bs"), []) self.assertEqual(ed.find("ct","cs"), []) # Scan contents tsvs = [ ("at","as","A1"), ("at","as","A2") ] self.assertEqual(list(ed.iterateAll()), tsvs) self.assertEqual(ed.count(), 2) # Partial wildcard tests ed.insert("dt","ds","D1ts") ed.insert("dt","ds","D2ts") ed.insert("dt",None,"D1tn") ed.insert(None,"ds","D1ns") ed.insert(None,None,"D1nn") self.assertEqual(ed.find("dt","ds"), ["D1ts","D2ts","D1tn","D1ns","D1nn"]) # Scan contents tsvs = [ ("dt","ds","D1ts"), ("dt","ds","D2ts") , ("dt",None,"D1tn") , ("at","as","A1"), ("at","as","A2") , (None,"ds","D1ns") , (None,None,"D1nn") ] self.assertEqual(list(ed.iterateAll()), tsvs) self.assertEqual(ed.count(), 7) # Partial wildcard tests in opposite order of insertion ed.insert(None,None,"E3nn") ed.insert(None,"es","E3ns") ed.insert("et",None,"E3tn") ed.insert("et","es","E4ts") ed.insert("et","es","E3ts") self.assertEqual(ed.find("et","es"), ["E4ts","E3ts","E3tn","E3ns","D1nn","E3nn"]) return # Test event+source keyed dictionary special wildcard scan functions def testEventTypeSourceDict2(self): Trace("testEventTypeSourceDict2","TestEventPubSub") # Construct a test dinctionary ed = EventTypeSourceDict() tsvs = [ ("bt","bs","B1"), ("bt","bs","B2") , ("at","as","A1"), ("at","as","A2") , (None,None,"N1"), (None,None,"N2") ] for (t,s,v) in tsvs: ed.insert(t, s, v) self.assertEqual(list(ed.iterateAll()), tsvs) self.assertEqual(ed.count(), 6) # Test wildcard scanning operations self.assertEqual(list(ed.iterateWild(None,None)), tsvs) self.assertEqual(list(ed.iterateWild("at","as")), [("at","as","A1"), ("at","as","A2"), (None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild("at",None)), [("at","as","A1"), ("at","as","A2"), (None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild(None,"as")), [("at","as","A1"), ("at","as","A2"), (None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild("bt","bs")), [("bt","bs","B1"), ("bt","bs","B2"), (None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild("bt",None)), [("bt","bs","B1"), ("bt","bs","B2"), (None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild(None,"bs")), [("bt","bs","B1"), ("bt","bs","B2"), (None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild("ct","cs")), [(None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild("ct",None)), [(None,None,"N1"), (None,None,"N2")]) self.assertEqual(list(ed.iterateWild(None,"cs")), [(None,None,"N1"), (None,None,"N2")]) return # Test plain iteration over event+source keyed dictionary def testEventTypeSourceDictIterate(self): Trace("testEventTypeSourceDictIterate","TestEventPubSub") ed = EventTypeSourceDict() ed.insert("et","es","A1") ed.insert(None,None,"N1") ed.insert(None,"es","A1") ed.insert("et",None,"A1") cnt1 = 0 for entry in ed.iterate("et","es"): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 4) cnt1 = 0 for entry in ed.iterate("et",None): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 2) cnt1 = 0 for entry in ed.iterate(None,"es"): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 2) cnt1 = 0 for entry in ed.iterate(None,None): cnt1 = cnt1 + 1 self.assertEqual(cnt1, 1) # Test publish/subscribe operations and event delivery def testPublishT1S1(self): Trace("testPublishT1S1","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (True, False, False, False, True, True, True, False) self.doTestPublish("t1","s1",expectTriggered) def testPublishT2S1(self): Trace("testPublishT2S1","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (False, True, False, False, False, True, True, True) self.doTestPublish("t2","s1",expectTriggered) def testPublishT1S2(self): Trace("testPublishT1S2","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (False, False, True, False, True, False, True, False) self.doTestPublish("t1","s2",expectTriggered) def testPublishT2S2(self): Trace("testPublishT2S2","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (False, False, False, True, False, False, True, False) self.doTestPublish("t2","s2",expectTriggered) def testPublishT1S3(self): Trace("testPublishT1S3","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (False, False, False, False, True, False, True, False) self.doTestPublish("t1","s3",expectTriggered) def testPublishT3S1(self): Trace("testPublishT3S1","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (False, False, False, False, False, True, True, False) self.doTestPublish("t3","s1",expectTriggered) def testPublishT3S3(self): Trace("testPublishT3S3","TestEventPubSub") self.setUpRouter() # A B C D E F G H expectTriggered = (False, False, False, False, False, False, True, False) self.doTestPublish("t3","s3",expectTriggered) def testUnsubscribe1(self): Trace("testUnsubscribe1","TestEventPubSub") self.setUpRouter() self.router.unsubscribe(self.handlers[0], evtype="t1", source="s1") self.router.unsubscribe(self.handlers[6]) # A B C D E F G H expectTriggered = (False, False, False, False, True, True, False, False) self.doTestPublish("t1","s1",expectTriggered) def testUnsubscribe2(self): Trace("testUnsubscribe2","TestEventPubSub") self.setUpRouter() self.router.unsubscribe(self.handlers[4], evtype="t1") self.router.unsubscribe(self.handlers[5], source="s1") # A B C D E F G H expectTriggered = (True, False, False, False, False, False, True, False) self.doTestPublish("t1","s1",expectTriggered) def testUnsubscribe3(self): Trace("testUnsubscribe3","TestEventPubSub") self.setUpRouter() self.router.unsubscribe(self.handlers[6]) self.router.unsubscribe(self.handlers[4], evtype="t1") self.router.unsubscribe(self.handlers[5], source="s1") self.router.unsubscribe(self.handlers[0], evtype="t1", source="s1") # A B C D E F G H expectTriggered = (False, False, False, False, False, False, False, False) self.doTestPublish("t1","s1",expectTriggered) def testWatch1(self): Trace("testWatch1","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") w2 = MyEventHandler("W2") self.router.watch(5, w1, evtype="t1") self.router.watch(5, w2, evtype="t2") w1.resetWatched() w2.resetWatched() self.router.subscribe(60, h1, evtype="t1", source="s1") assert w1.isWatched(),"Watch for t1 not triggered on subscribe" assert not w2.isWatched(), "Watch t2 triggered on subscribe" def testWatch2(self): Trace("testWatch2","TestEventPubSub") self.setUpRouter() w1 = MyEventHandler("W1") w2 = MyEventHandler("W2") self.router.watch(5, w1, evtype="t1") self.router.watch(5, w2, evtype="t2") w1.resetWatched() w2.resetWatched() self.router.subscribe(60, self.handlers[0], evtype="t2") assert not w1.isWatched(), "Watch t1 triggered on subscribe" assert w2.isWatched(), "Watch t2 not triggered on subscribe" def testWatch3(self): Trace("testWatch3","TestEventPubSub") self.setUpRouter() self.router.subscribe(60, self.handlers[0], evtype="t1", source="s1") self.router.subscribe(60, self.handlers[0], evtype="t2") w1 = MyEventHandler("W1") w2 = MyEventHandler("W2") self.router.watch(5, w1, evtype="t1") self.router.watch(5, w2, evtype="t2") w1.resetWatched() w2.resetWatched() self.router.unsubscribe(self.handlers[0], evtype="t1", source="s1") assert w1.isWatched(), "Watch t1 not triggered on unsubscribe" assert not w2.isWatched(), "Watch t2 triggered on unsubscribe" def testWatch4(self): Trace("testWatch4","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") w2 = MyEventHandler("W2") self.router.subscribe(60, h1, evtype="t1", source="s1") self.router.subscribe(60, h1, evtype="t2") self.router.watch(5, w1, evtype="t1") self.router.watch(5, w2, evtype="t2") w1.resetWatched() w2.resetWatched() self.router.unsubscribe(h1, evtype="t2") assert not w1.isWatched(), "Watch t1 triggered on unsubscribe" assert w2.isWatched(), "Watch t2 not triggered on unsubscribe" # Watch with wildcard subscribe/unsubscribe def testWatch5(self): Trace("testWatch5","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.watch(5, w1, evtype="t1") w1.resetWatched() self.router.subscribe(60, h1) assert w1.isWatched(),"Watch t1 not triggered on wild subscribe" w1.resetWatched() assert not w1.isWatched(),"Watch not reset" self.router.unsubscribe(h1) assert w1.isWatched(),"Watch t1 not triggered on wild unsubscribe" # Wildcard watch with normal subscribe def testWatch6(self): Trace("testWatch6","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.watch(5, w1) w1.resetWatched() self.router.subscribe(60, h1, evtype="t1", source="s1") assert w1.isWatched(),"Watch * not triggered on subscribe" w1.resetWatched() self.router.unsubscribe(h1, evtype="t1", source="s1") assert w1.isWatched(),"Watch * not triggered on unsubscribe" # Wildcard watch with wildcard subscribe def testWatch7(self): Trace("testWatch7","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.watch(5, w1) w1.resetWatched() self.router.subscribe(60, h1) assert w1.isWatched(),"Watch * not triggered on wild subscribe" w1.resetWatched() self.router.unsubscribe(h1) assert w1.isWatched(),"Watch * not triggered on wild unsubscribe" # Test form of subscribe event delivered to watcher def testWatch8(self): Trace("testWatch8","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.watch(5, w1, evtype="t1") self.router.subscribe(60, h1, evtype="t1", source="s1") assert w1.isWatched(),"Watch for t1 not triggered on subscribe" ev = w1.getSubEvent() Trace("testWatch8 - ev %s:%s"%(str(ev),repr(ev.getPayload())),"TestEventPubSub") assert ev.getType() == URI.EventSubscribeType, "Subscribe event type must be URI.EventSubscribeType" assert ev.getSource() == h1.getUri(), "Subscribe event agent not handler URI" assert ev.getPayload()[0] == 60, "Subscribe payload[0] not interval" assert ev.getPayload()[1] == "t1", "Subscribe payload[1] not subscribed event type" assert ev.getPayload()[2] == "s1", "Subscribe payload[2] not subscribed event source" return # Test watch event delivered for prior subscription def testWatchPrior1(self): Trace("testWatchPrior1","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.subscribe(60, h1, evtype="t1", source="s1") self.router.watch(5,w1,evtype="t1") assert w1.isWatched(),"Watch t1 not triggered for subscribe that precedes watch" # Test watch event is delivered for prior wildcard subscription def testWatchPrior2(self): Trace("testWatchPrior2","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.subscribe(60, h1) self.router.watch(5, w1, evtype="t1") assert w1.isWatched(),"Watch t1 not triggered for prior wildcard subscribe" # Test wildcard watch event is delivered for prior subscription def testWatchPrior3(self): Trace("testWatchPrior3","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.subscribe(60, h1, evtype="t1", source="s1") self.router.watch(5, w1) assert w1.isWatched(),"Watch * not triggered for prior wildcard subscribe" # Test wildcard watch event is delivered for prior wildcard subscription def testWatchPrior4(self): Trace("testWatchPrior4","TestEventPubSub") self.setUpRouter() h1 = MyEventHandler("H1") w1 = MyEventHandler("W1") self.router.subscribe(60, h1) self.router.watch(5, w1) assert w1.isWatched(),"Watch * not triggered for prior wildcard subscribe" # Placeholder/sentinel test cases def testUnits(self): assert (True) def testComponents(self): assert (True) def testIntegration(self): assert (True) def testPending(self): assert (True)