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)
