def test_event_single(self): '''Test a single event is received''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') evt1 = me.get_event(tag='evt1') self.assertGotEvent(evt1, {'data': 'foo1'})
def test_event_single(self): """Test a single event is received""" with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="evt1") self.assertGotEvent(evt1, {"data": "foo1"})
def test_event_single(sock_dir): """Test a single event is received""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="evt1") _assert_got_event(evt1, {"data": "foo1"})
def test_event_matching_all_when_tag_is_None(self): """Test event matching all when not passing a tag""" with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event() self.assertGotEvent(evt1, {"data": "foo1"})
def test_set_event_handler(self): """ Test subscribing events using set_event_handler """ with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir) event_listener = saltnado.EventListener( {}, # we don't use mod_opts, don't save? { "sock_dir": self.sock_dir, "transport": "zeromq" }, ) self._finished = False # fit to event_listener's behavior event_future = event_listener.get_event( self, tag="evt", callback=self.stop, timeout=1, ) # get an event future me.fire_event({"data": "foo"}, "evt") # fire an event we do want self.wait() # check that we subscribed the event we wanted self.assertEqual(len(event_listener.timeout_map), 0)
def test_event_matching_all(sock_dir): """Test an all match""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="") _assert_got_event(evt1, {"data": "foo1"})
def test_simple(self): """ Test getting a few events """ with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir) event_listener = saltnado.EventListener( {}, # we don't use mod_opts, don't save? { "sock_dir": self.sock_dir, "transport": "zeromq" }, ) self._finished = False # fit to event_listener's behavior event_future = event_listener.get_event( self, "evt1", callback=self.stop) # get an event future me.fire_event({"data": "foo2"}, "evt2") # fire an event we don't want me.fire_event({"data": "foo1"}, "evt1") # fire an event we do want self.wait() # wait for the future # check that we got the event we wanted self.assertTrue(event_future.done()) self.assertEqual(event_future.result()["tag"], "evt1") self.assertEqual(event_future.result()["data"]["data"], "foo1")
async def test_simple(sock_dir): """ Test getting a few events """ with eventpublisher_process(sock_dir): with salt.utils.event.MasterEvent(sock_dir) as me: request = Request() event_listener = saltnado.EventListener( {}, # we don't use mod_opts, don't save? { "sock_dir": sock_dir, "transport": "zeromq" }, ) event_future = event_listener.get_event( request, "evt1") # get an event future me.fire_event({"data": "foo2"}, "evt2") # fire an event we don't want me.fire_event({"data": "foo1"}, "evt1") # fire an event we do want await event_future # wait for the future # check that we got the event we wanted assert event_future.done() assert event_future.result()["tag"] == "evt1" assert event_future.result()["data"]["data"] == "foo1"
async def test_set_event_handler(sock_dir): """ Test subscribing events using set_event_handler """ with eventpublisher_process(sock_dir): with salt.utils.event.MasterEvent(sock_dir) as me: request = Request() event_listener = saltnado.EventListener( {}, # we don't use mod_opts, don't save? { "sock_dir": sock_dir, "transport": "zeromq" }, ) event_future = event_listener.get_event( request, tag="evt", timeout=1, ) # get an event future me.fire_event({"data": "foo"}, "evt") # fire an event we do want await event_future # wait for the future # check that we subscribed the event we wanted assert len(event_listener.timeout_map) == 0
def test_event_no_timeout(self): """Test no wait timeout, we should block forever, until we get one""" with eventpublisher_process(self.sock_dir): with salt.utils.event.MasterEvent(self.sock_dir, listen=True) as me: with eventsender_process({"data": "foo2"}, "evt2", self.sock_dir, 5): evt = me.get_event(tag="evt2", wait=0, no_block=False) self.assertGotEvent(evt, {"data": "foo2"})
def test_event_matching_regex(self): """Test a regex match""" with eventpublisher_process(self.sock_dir): with salt.utils.event.MasterEvent(self.sock_dir, listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="^ev", match_type="regex") self.assertGotEvent(evt1, {"data": "foo1"})
def test_event_matching_all_when_tag_is_None(sock_dir): """Test event matching all when not passing a tag""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event() _assert_got_event(evt1, {"data": "foo1"})
def test_event_matching_all(self): '''Test an all match''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') evt1 = me.get_event(tag='') self.assertGotEvent(evt1, {'data': 'foo1'})
def test_event_matching_all(self): """Test an all match""" with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="") self.assertGotEvent(evt1, {"data": "foo1"})
def test_event_matching_all_when_tag_is_None(self): '''Test event matching all when not passing a tag''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') evt1 = me.get_event() self.assertGotEvent(evt1, {'data': 'foo1'})
def test_simple(self): """ Test getting a few events ''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir) event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save? {'sock_dir': self.sock_dir, 'transport': 'zeromq'}) self._finished = False # fit to event_listener's behavior event_future = event_listener.get_event( self, "evt1", callback=self.stop ) # get an event future me.fire_event({"data": "foo2"}, "evt2") # fire an event we don't want me.fire_event({"data": "foo1"}, "evt1") # fire an event we do want self.wait() # wait for the future # check that we got the event we wanted self.assertTrue(event_future.done()) self.assertEqual(event_future.result()["tag"], "evt1") self.assertEqual(event_future.result()["data"]["data"], "foo1") @skipIf(True, "SLOWTEST skip") def test_set_event_handler(self): """ Test subscribing events using set_event_handler ''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir) event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save? {'sock_dir': self.sock_dir, 'transport': 'zeromq'}) self._finished = False # fit to event_listener's behavior event_future = event_listener.get_event( self, tag="evt", callback=self.stop, timeout=1, ) # get an event future me.fire_event({"data": "foo"}, "evt") # fire an event we do want self.wait() # check that we subscribed the event we wanted self.assertEqual(len(event_listener.timeout_map), 0) @skipIf(True, "SLOWTEST skip") def test_timeout(self): """ Make sure timeouts work correctly ''' with eventpublisher_process(self.sock_dir): event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save? {'sock_dir': self.sock_dir, 'transport': 'zeromq'}) self._finished = False # fit to event_listener's behavior event_future = event_listener.get_event( self, tag="evt1", callback=self.stop, timeout=1, ) # get an event future self.wait() self.assertTrue(event_future.done()) with self.assertRaises(saltnado.TimeoutException): event_future.result()
def test_event_no_timeout(self): '''Test no wait timeout, we should block forever, until we get one ''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) with eventsender_process({'data': 'foo2'}, 'evt2', self.sock_dir, 5): evt = me.get_event(tag='evt2', wait=0, no_block=False) self.assertGotEvent(evt, {'data': 'foo2'})
def test_event_single_wait_0_no_block_False(self): '''Test a single event is received with wait=0 and no_block=False and doesn't spin the while loop''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') # This is too fast and will be None but assures we're not blocking evt1 = me.get_event(wait=0, tag="evt1", no_block=False) self.assertGotEvent(evt1, {"data": "foo1"})
def test_event_single_wait_0_no_block_False(sock_dir): """Test a single event is received with wait=0 and no_block=False and doesn't spin the while loop""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") # This is too fast and will be None but assures we're not blocking evt1 = me.get_event(wait=0, tag="evt1", no_block=False) _assert_got_event(evt1, {"data": "foo1"})
def test_event_timeout(self): """Test no event is received if the timeout is reached""" with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="evt1") self.assertGotEvent(evt1, {"data": "foo1"}) evt2 = me.get_event(tag="evt1") self.assertIsNone(evt2)
def test_event_many(sock_dir): """Test a large number of events, one at a time""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: for i in range(500): me.fire_event({"data": "{}".format(i)}, "testevents") evt = me.get_event(tag="testevents") _assert_got_event(evt, {"data": "{}".format(i)}, "Event {}".format(i))
def test_event_many(self): '''Test a large number of events, one at a time''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) for i in range(500): me.fire_event({'data': '{0}'.format(i)}, 'testevents') evt = me.get_event(tag='testevents') self.assertGotEvent(evt, {'data': '{0}'.format(i)}, 'Event {0}'.format(i))
def test_event_timeout(sock_dir): """Test no event is received if the timeout is reached""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") evt1 = me.get_event(tag="evt1") _assert_got_event(evt1, {"data": "foo1"}) evt2 = me.get_event(tag="evt1") assert evt2 is None
def test_event_many(self): """Test a large number of events, one at a time""" with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) for i in range(500): me.fire_event({"data": "{0}".format(i)}, "testevents") evt = me.get_event(tag="testevents") self.assertGotEvent(evt, {"data": "{0}".format(i)}, "Event {0}".format(i))
def test_event_timeout(self): '''Test no event is received if the timeout is reached''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') evt1 = me.get_event(tag='evt1') self.assertGotEvent(evt1, {'data': 'foo1'}) evt2 = me.get_event(tag='evt1') self.assertIsNone(evt2)
def test_event_not_subscribed(sock_dir): """Test get_event drops non-subscribed events""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") me.fire_event({"data": "foo2"}, "evt2") evt2 = me.get_event(tag="evt2") evt1 = me.get_event(tag="evt1") _assert_got_event(evt2, {"data": "foo2"}) assert evt1 is None
def test_event_not_subscribed(self): '''Test get_event drops non-subscribed events''' with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') me.fire_event({'data': 'foo2'}, 'evt2') evt2 = me.get_event(tag='evt2') evt1 = me.get_event(tag='evt1') self.assertGotEvent(evt2, {'data': 'foo2'}) self.assertIsNone(evt1)
def test_event_not_subscribed(self): """Test get_event drops non-subscribed events""" with eventpublisher_process(self.sock_dir): me = salt.utils.event.MasterEvent(self.sock_dir, listen=True) me.fire_event({"data": "foo1"}, "evt1") me.fire_event({"data": "foo2"}, "evt2") evt2 = me.get_event(tag="evt2") evt1 = me.get_event(tag="evt1") self.assertGotEvent(evt2, {"data": "foo2"}) self.assertIsNone(evt1)
def test_event_many_backlog(sock_dir): """Test a large number of events, send all then recv all""" with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: # Must not exceed zmq HWM for i in range(500): me.fire_event({"data": "{}".format(i)}, "testevents") for i in range(500): evt = me.get_event(tag="testevents") _assert_got_event(evt, {"data": "{}".format(i)}, "Event {}".format(i))
def test_event_nested_sub_all(sock_dir): """Test nested event subscriptions do not drop events, get event for all tags""" # Show why not to call get_event(tag='') with eventpublisher_process(str(sock_dir)): with salt.utils.event.MasterEvent(str(sock_dir), listen=True) as me: me.fire_event({"data": "foo1"}, "evt1") me.fire_event({"data": "foo2"}, "evt2") evt2 = me.get_event(tag="") evt1 = me.get_event(tag="") _assert_got_event(evt2, {"data": "foo2"}, expected_failure=True) _assert_got_event(evt1, {"data": "foo1"}, expected_failure=True)