def setUp(self):
super(KombuIntegrationTest, self).setUp()
self.exchange_name = 'test-%s' % uuid.uuid4()
self.discovery_hub = StaticServiceRegistryHub()
self.the_container, self.the_interface = self.create_container(TestInterface, 'test')
self.lymph_client = self.create_client()
class MockServiceNetwork(object):
def __init__(self):
self.service_containers = {}
self.next_port = 1
self.discovery_hub = StaticServiceRegistryHub()
self.events = LocalEventSystem()
def add_service(self, cls, interface_name=None, **kwargs):
kwargs.setdefault('ip', '300.0.0.1')
kwargs.setdefault('port', self.next_port)
self.next_port += 1
registry = self.discovery_hub.create_registry()
container = MockServiceContainer(registry=registry, events=self.events, **kwargs)
container.install_interface(cls, name=interface_name)
self.service_containers[container.endpoint] = container
container._mock_network = self
return container
def start(self):
for container in six.itervalues(self.service_containers):
container.start()
def stop(self, **kwargs):
for container in six.itervalues(self.service_containers):
container.stop()
def join(self):
for container in six.itervalues(self.service_containers):
container.join()
class MockServiceNetwork(object):
def __init__(self):
self.service_containers = {}
self.next_port = 1
self.discovery_hub = StaticServiceRegistryHub()
self.events = LocalEventSystem()
def add_service(self, cls, interface_name=None, **kwargs):
port = self.next_port
self.next_port += 1
registry = self.discovery_hub.create_registry()
container = MockServiceContainer(
registry=registry,
events=self.events,
rpc=MockRPCServer(ip='300.0.0.1', port=port, mock_network=self),
**kwargs)
container.install_interface(cls, name=interface_name)
self.service_containers[container.endpoint] = container
container._mock_network = self
return container
def start(self):
for container in six.itervalues(self.service_containers):
container.start()
def stop(self, **kwargs):
for container in six.itervalues(self.service_containers):
container.stop()
def join(self):
for container in six.itervalues(self.service_containers):
container.join()
class MockServiceNetwork(object):
def __init__(self):
self.service_containers = {}
self.next_port = 1
self.discovery_hub = StaticServiceRegistryHub()
self.events = LocalEventSystem()
def add_service(self, **kwargs):
port = self.next_port
self.next_port += 1
registry = self.discovery_hub.create_registry()
container = MockServiceContainer(
registry=registry,
events=self.events,
rpc=MockRPCServer(ip="127.0.0.1", port=port, mock_network=self),
metrics=Aggregator(),
**kwargs
)
self.service_containers[container.endpoint] = container
container._mock_network = self
return container
def start(self):
for container in six.itervalues(self.service_containers):
container.start()
def stop(self, **kwargs):
for container in six.itervalues(self.service_containers):
container.stop()
def join(self):
for container in six.itervalues(self.service_containers):
container.join()
class KombuIntegrationTest(LymphIntegrationTestCase, AsyncTestsMixin):
use_zookeeper = False
def setUp(self):
super(KombuIntegrationTest, self).setUp()
self.exchange_name = 'test-%s' % uuid.uuid4()
self.discovery_hub = StaticServiceRegistryHub()
self.the_container, self.the_interface = self.create_container(TestInterface, 'test')
self.lymph_client = self.create_client()
def tearDown(self):
super(LymphIntegrationTestCase, self).tearDown()
connection = self.get_kombu_connection()
exchange = kombu.Exchange(self.exchange_name)
exchange(connection).delete()
# FIXME: there should be a better way to get this exchange name
waiting_exchange = kombu.Exchange('%s_waiting' % self.exchange_name)
waiting_exchange(connection).delete()
# FIXME: there should be a better way to get the queue names
for name in ('foo-wait_500', 'test-on_foo'):
queue = kombu.Queue(name)
queue(connection).delete()
def get_kombu_connection(self):
return kombu.Connection(transport='amqp', host='127.0.0.1')
def create_event_system(self, **kwargs):
return KombuEventSystem(self.get_kombu_connection(), self.exchange_name)
def create_registry(self, **kwargs):
return self.discovery_hub.create_registry(**kwargs)
def received_check(self, n):
def check():
return len(self.the_interface.collected_events) == n
return check
def test_emit(self):
self.lymph_client.emit('foo', {})
self.assert_eventually_true(self.received_check(1), timeout=2)
self.assertEqual(self.the_interface.collected_events[0].evt_type, 'foo')
def test_delayed_emit(self):
self.lymph_client.emit('foo', {}, delay=.5)
self.assert_temporarily_true(self.received_check(0), timeout=.2)
self.assert_eventually_true(self.received_check(1), timeout=.5)
self.assertEqual(self.the_interface.collected_events[0].evt_type, 'foo')
def __init__(self):
self.service_containers = {}
self.next_port = 1
self.discovery_hub = StaticServiceRegistryHub()
self.events = LocalEventSystem()
def __init__(self):
self.service_containers = {}
self.next_port = 1
self.discovery_hub = StaticServiceRegistryHub()
self.events = LocalEventSystem()
class KombuIntegrationTest(LymphIntegrationTestCase, AsyncTestsMixin):
use_zookeeper = False
def setUp(self):
super(KombuIntegrationTest, self).setUp()
self.exchange_name = "test-%s" % uuid.uuid4()
self.discovery_hub = StaticServiceRegistryHub()
self.the_container, self.the_interface = self.create_container(TestInterface, "test")
self.the_container_broadcast, self.the_interface_broadcast = self.create_container(
TestEventBroadcastInterface, "test"
)
self.lymph_client = self.create_client()
def tearDown(self):
super(KombuIntegrationTest, self).tearDown()
connection = self.get_kombu_connection()
exchange = kombu.Exchange(self.exchange_name)
exchange(connection).delete()
waiting_exchange = kombu.Exchange(self.the_container.events.waiting_exchange.name)
waiting_exchange(connection).delete()
retry_exchange = kombu.Exchange(self.the_container.events.retry_exchange.name)
retry_exchange(connection).delete()
for q in ("test-on_foo", "test-on_retryable_foo"):
self.delete_queue(q)
def delete_queue(self, name):
connection = self.get_kombu_connection()
queue = kombu.Queue(name)
queue(connection).delete()
def get_kombu_connection(self):
return kombu.Connection(transport="amqp", host="127.0.0.1")
def create_event_system(self, **kwargs):
return KombuEventSystem(self.get_kombu_connection(), self.exchange_name)
def create_registry(self, **kwargs):
return self.discovery_hub.create_registry(**kwargs)
def received_check(self, n):
def check():
return len(self.the_interface.collected_events) == n
return check
def received_broadcast_check(self, n):
def check():
return (len(self.the_interface.collected_events) + len(self.the_interface_broadcast.collected_events)) == n
return check
def test_emit(self):
self.lymph_client.emit("foo", {})
self.assert_eventually_true(self.received_check(1), timeout=10)
self.assertEqual(self.the_interface.collected_events[0].evt_type, "foo")
def test_delayed_emit(self):
self.lymph_client.emit("foo", {}, delay=0.5)
self.addCleanup(self.delete_queue, "foo-wait_500")
self.assert_temporarily_true(self.received_check(0), timeout=0.2)
self.assert_eventually_true(self.received_check(1), timeout=10)
self.assertEqual(self.the_interface.collected_events[0].evt_type, "foo")
def test_broadcast_event(self):
self.lymph_client.emit("foo_broadcast", {})
self.assert_eventually_true(self.received_broadcast_check(2), timeout=10)
self.assertEqual(self.the_interface.collected_events[0].evt_type, "foo_broadcast")
self.assertEqual(self.the_interface_broadcast.collected_events[0].evt_type, "foo_broadcast")
def test_retryable_event(self):
self.lymph_client.emit("retryable_foo", {})
self.assert_eventually_true(self.received_check(3), timeout=10)
class KombuIntegrationTest(LymphIntegrationTestCase, AsyncTestsMixin):
use_zookeeper = False
def setUp(self):
super(KombuIntegrationTest, self).setUp()
self.exchange_name = 'test-%s' % uuid.uuid4()
self.discovery_hub = StaticServiceRegistryHub()
self.the_container, self.the_interface = self.create_container(
TestInterface, 'test')
self.the_container_broadcast, self.the_interface_broadcast = self.create_container(
TestEventBroadcastInterface, 'test')
self.lymph_client = self.create_client()
def tearDown(self):
super(KombuIntegrationTest, self).tearDown()
connection = self.get_kombu_connection()
exchange = kombu.Exchange(self.exchange_name)
exchange(connection).delete()
waiting_exchange = kombu.Exchange(
self.the_container.events.waiting_exchange.name)
waiting_exchange(connection).delete()
retry_exchange = kombu.Exchange(
self.the_container.events.retry_exchange.name)
retry_exchange(connection).delete()
for q in ('test-on_foo', 'test-on_retryable_foo'):
self.delete_queue(q)
def delete_queue(self, name):
connection = self.get_kombu_connection()
queue = kombu.Queue(name)
queue(connection).delete()
def get_kombu_connection(self):
return kombu.Connection(transport='amqp', host='127.0.0.1')
def create_event_system(self, **kwargs):
return KombuEventSystem(self.get_kombu_connection(),
self.exchange_name)
def create_registry(self, **kwargs):
return self.discovery_hub.create_registry(**kwargs)
def received_check(self, n):
def check():
return len(self.the_interface.collected_events) == n
return check
def received_broadcast_check(self, n):
def check():
return (len(self.the_interface.collected_events) +
len(self.the_interface_broadcast.collected_events)) == n
return check
def test_emit(self):
self.lymph_client.emit('foo', {})
self.assert_eventually_true(self.received_check(1), timeout=10)
self.assertEqual(self.the_interface.collected_events[0].evt_type,
'foo')
def test_delayed_emit(self):
self.lymph_client.emit('foo', {}, delay=.5)
self.addCleanup(self.delete_queue, 'foo-wait_500')
self.assert_temporarily_true(self.received_check(0), timeout=.2)
self.assert_eventually_true(self.received_check(1), timeout=10)
self.assertEqual(self.the_interface.collected_events[0].evt_type,
'foo')
def test_broadcast_event(self):
self.lymph_client.emit('foo_broadcast', {})
self.assert_eventually_true(self.received_broadcast_check(2),
timeout=10)
self.assertEqual(self.the_interface.collected_events[0].evt_type,
'foo_broadcast')
self.assertEqual(
self.the_interface_broadcast.collected_events[0].evt_type,
'foo_broadcast')
def test_retryable_event(self):
self.lymph_client.emit('retryable_foo', {})
self.assert_eventually_true(self.received_check(3), timeout=10)
