def test_execute_sync_during_callback(self): event_topic = UuidGenerator.generate_id_as_string() req_topic = UuidGenerator.generate_id_as_string() with self.create_client() as client: client.connect() # callback def event_callback(event): try: req = Request(destination_topic=req_topic) client.sync_request(req) except Exception, e: self.exceptions.append(e) raise e ec = EventCallback() ec.on_event = event_callback client.add_event_callback(event_topic, ec) time.sleep(self.SLEEP_TIME) # Check the time evt = Event(destination_topic=event_topic) client.send_event(evt) time.sleep(self.SLEEP_TIME) self.assertTrue(self.exceptions[0] is not None) self.assertTrue("different thread" in self.exceptions[0].message)
def test_execute_sync_during_callback(self): event_topic = UuidGenerator.generate_id_as_string() req_topic = UuidGenerator.generate_id_as_string() with self.create_client() as client: client.connect() # callback def event_callback(_): with self.event_received_condition: self.event_received = True try: req = Request(destination_topic=req_topic) client.sync_request(req) except Exception as ex: # pylint: disable=broad-except self.request_exception_message = str(ex) self.event_received_condition.notify_all() callback = EventCallback() callback.on_event = event_callback client.add_event_callback(event_topic, callback) event = Event(destination_topic=event_topic) client.send_event(event) start = time.time() with self.event_received_condition: while (time.time() - start < self.MAX_WAIT) and \ not self.event_received: self.event_received_condition.wait(self.MAX_WAIT) self.assertIsNotNone(self.request_exception_message) self.assertIn("different thread", self.request_exception_message)
def test_event(self): source_client_guid = UuidGenerator.generate_id_as_string() source_broker_guid = UuidGenerator.generate_id_as_string() event = Event(destination_topic="") event._source_client_id = source_client_guid event._source_broker_id = source_broker_guid event.broker_ids = ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] event.client_ids = ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] event.payload = str.encode("EVENT") pp.pprint(vars(event)) message = event._to_bytes() pp.pprint(message) result = Message._from_bytes(message) pp.pprint(vars(result)) assert result.source_client_id == source_client_guid assert result.source_broker_id == source_broker_guid assert result.broker_ids == ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] assert result.client_ids == ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] assert result.payload == str.encode("EVENT") assert result.message_type == Message.MESSAGE_TYPE_EVENT
def test_event(self): source_client_guid = UuidGenerator.generate_id_as_string() source_broker_guid = UuidGenerator.generate_id_as_string() source_broker_ids = ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] source_client_ids = ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] source_payload = "EVENT".encode() event = Event(destination_topic="") event._source_client_id = source_client_guid event._source_broker_id = source_broker_guid event.broker_ids = source_broker_ids event.client_ids = source_client_ids event.payload = source_payload PP.pprint(vars(event)) message = event._to_bytes() PP.pprint(message) result = Message._from_bytes(message) PP.pprint(vars(result)) self.assertEqual(source_client_guid, result.source_client_id) self.assertEqual(source_broker_guid, result.source_broker_id) self.assertEqual(source_broker_ids, result.broker_ids) self.assertEqual(source_client_ids, result.client_ids) self.assertEqual(source_payload, result.payload) self.assertEqual(Message.MESSAGE_TYPE_EVENT, result.message_type)
def measure_performance(self, client, with_wildcard, topic_exists): sub_count = 10000 query_multiplier = 10 topic_prefix = "/topic/" + UuidGenerator.generate_id_as_string() + "/" event_count = [0] message_ids = set() payload = UuidGenerator.generate_id_as_string() payload_as_bytes = payload.encode() message_id_condition = Condition() callback = EventCallback() def on_event(event): if event.payload == payload_as_bytes: with message_id_condition: event_count[0] += 1 message_ids.add(event.message_id) message_id_condition.notify() if len(message_ids) % sub_count == 0: print("Messages size: " + str(len(message_ids))) callback.on_event = on_event client.add_event_callback("#", callback, False) if with_wildcard: client.subscribe(topic_prefix + "#") for i in range(sub_count): if i % 1000 == 0: print("Subscribed: " + str(i)) client.subscribe(topic_prefix + str(i)) print("Subscribed.") start_time = time.time() for j in range(sub_count * query_multiplier): evt = Event(topic_prefix + str(j % sub_count + (sub_count if not topic_exists else 0))) evt.payload = payload client.send_event(evt) with message_id_condition: while len(message_ids) != sub_count * query_multiplier \ or event_count[0] != sub_count * query_multiplier * (2 if with_wildcard and topic_exists else 1): current_event = event_count[0] message_id_condition.wait(5) if current_event == event_count[0]: self.fail("Event wait timeout") self.assertEqual(sub_count * query_multiplier, len(message_ids)) self.assertEqual( sub_count * query_multiplier * (2 if with_wildcard and topic_exists else 1), event_count[0]) return time.time() - start_time
def measure_performance(self, client, with_wildcard, topic_exists): SUB_COUNT = 10000 QUERY_MULTIPLIER = 10 TOPIC_PREFIX = "/topic/" + UuidGenerator.generate_id_as_string() + "/" event_count = [0] message_ids = set() PAYLOAD = UuidGenerator.generate_id_as_string() message_id_condition = Condition() cb = EventCallback() def on_event(event): if event.payload == PAYLOAD: with message_id_condition: event_count[0] += 1 message_ids.add(event.message_id) message_id_condition.notify() if len(message_ids) % SUB_COUNT == 0: print "Messages size: " + str(len(message_ids)) cb.on_event = on_event client.add_event_callback("#", cb, False) if with_wildcard: client.subscribe(TOPIC_PREFIX + "#") for i in range(SUB_COUNT): if i % 1000 == 0: print "Subscribed: " + str(i) client.subscribe(TOPIC_PREFIX + str(i)) print "Subscribed." start_time = time.time() for j in range(SUB_COUNT * QUERY_MULTIPLIER): evt = Event(TOPIC_PREFIX + str(j % SUB_COUNT + (SUB_COUNT if not topic_exists else 0))) evt.payload = PAYLOAD client.send_event(evt) with message_id_condition: while len(message_ids) != SUB_COUNT * QUERY_MULTIPLIER \ or event_count[0] != SUB_COUNT * QUERY_MULTIPLIER * (2 if with_wildcard and topic_exists else 1): current_event = event_count[0] message_id_condition.wait(5) if current_event == event_count[0]: self.fail("Event wait timeout") self.assertEquals(SUB_COUNT * QUERY_MULTIPLIER, len(message_ids)) self.assertEquals( SUB_COUNT * QUERY_MULTIPLIER * (2 if with_wildcard and topic_exists else 1), event_count[0]) return time.time() - start_time
def test_subs_count(self): clients = [] with self.create_client() as client: client.connect() for _ in range(6): _client = self.create_client() _client.connect() clients.append(_client) random1 = UuidGenerator.generate_id_as_string() random2 = UuidGenerator.generate_id_as_string() topic1 = "/foo/bar/" + random1 + "/" + random2 clients[0].subscribe(topic1) clients[1].subscribe(topic1) clients[2].subscribe(topic1) clients[3].subscribe("/foo/bar/" + random1 + "/#") clients[4].subscribe("/foo/+/" + random1 + "/#") topic2 = "/foo/baz/" + random2 clients[1].subscribe(topic2) clients[2].subscribe(topic2) clients[5].subscribe("#") def get_subs_count(topic): req = Request("/mcafee/service/dxl/broker/subs") req.payload = "{\"topic\":\"" + topic + "\"}" resp = client.sync_request(req, 5) return json.loads( resp.payload.decode("utf8").rstrip("\0"))["count"] def loop_until_expected_subs_count(expected_topic_count, topic): topic_count = get_subs_count(topic) start = time.time() while topic_count != expected_topic_count and \ time.time() - start < self.MAX_TIME: time.sleep(0.1) topic_count = get_subs_count(topic) return topic_count # Topic 1 expected_topic1_count = 6 self.assertEqual( expected_topic1_count, loop_until_expected_subs_count(expected_topic1_count, topic1)) # Topic 2 expected_topic2_count = 3 self.assertEqual( expected_topic2_count, loop_until_expected_subs_count(expected_topic2_count, topic2)) for _client in clients: _client.destroy()
def test_execute_async_callback_timeout(self): # TODO: Set SYSPROP_ASYNC_CALLBACK_CHECK_INTERVAL = 10000 when it is available def resp_callback(): pass cb = ResponseCallback() cb.on_response = resp_callback with self.create_client() as client: client.connect() req_topic = UuidGenerator.generate_id_as_string() missing_topic = UuidGenerator.generate_id_as_string() test_service = TestService(client, 1) def empty_on_request(request): pass test_service.on_request = empty_on_request reg_info = ServiceRegistrationInfo(client, "async_callback_test_service") reg_info.add_topic(req_topic, test_service) # Register the service client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) async_req = Request(destination_topic=req_topic) client.async_request( async_req, cb) # TODO: Use the method with timeout when is will available for i in range(0, 10): req = Request(destination_topic=req_topic) client.async_request( req, cb ) # TODO: Use the updated method with timeout when it is available req_for_error = Request(destination_topic=missing_topic) client.async_request(req_for_error) async_callback_count = client._get_async_callback_count() self.assertEquals(11, async_callback_count) for i in range(0, 20): print "asyncCallbackCount = " + str( client._get_async_callback_count()) time.sleep(1) req = Request(destination_topic=req_topic) client.async_request(req, cb) self.assertEquals(1, async_callback_count)
def register_test_service(self, client, service_type=None): topic = "broker_service_registry_test_service_" + \ UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( client, service_type or "broker_service_registry_test_service_" + UuidGenerator.generate_id_as_string()) callback = RequestCallback() callback.on_request = \ lambda request: client.send_response(Response(request)) reg_info.add_topic(topic, callback) client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) return reg_info
def test_error_message(self): with self.create_client() as client: test_service = TestService(client, 1) client.connect() error_code = 9090 error_message = "My error message" topic = UuidGenerator.generate_id_as_string() # # Create a test service that returns error messages # reg_info = ServiceRegistrationInfo(client, "testErrorMessageService") reg_info.add_topic(topic, test_service) client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) test_service.return_error = True test_service.error_code = error_code test_service.error_message = error_message client.add_request_callback(topic, test_service) # Send a request and ensure the response is an error message response = client.sync_request(Request(topic)) self.assertIsInstance(response, ErrorResponse, msg="Response is not an ErrorResponse") self.assertEqual(error_code, response.error_code) self.assertEqual(error_message, response.error_message)
def test_incoming_message_threading(self): max_wait = 30 thread_count = 10 thread_name_condition = threading.Condition() thread_name = set() event_topic = UuidGenerator.generate_id_as_string() with self.create_client( incoming_message_thread_pool_size=thread_count) as client: client.connect() event_callback = EventCallback() def on_event(_): with thread_name_condition: thread_name.add(threading.current_thread()) if len(thread_name) == thread_count: thread_name_condition.notify_all() event_callback.on_event = on_event client.add_event_callback(event_topic, event_callback) for _ in range(0, 1000): evt = Event(event_topic) client.send_event(evt) start = time.time() with thread_name_condition: while (time.time() - start < max_wait) and \ len(thread_name) < thread_count: thread_name_condition.wait(max_wait) self.assertEqual(thread_count, len(thread_name))
def test_multiple_registrations(self): service_registration_count = 10 request_received_count = [0] topic = UuidGenerator.generate_id_as_string() with self.create_client() as service_client: service_client.connect() def my_request(request): request_received_count[0] += 1 response = Response(request) service_client.send_response(response) reg_info = ServiceRegistrationInfo(service_client, "multiple_registrations_test") callback = RequestCallback() callback.on_request = my_request reg_info.add_topic(topic, callback) with self.create_client() as request_client: request_client.connect() for _ in range(0, service_registration_count): service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) request = Request(topic) response = request_client.sync_request( request, timeout=self.RESPONSE_WAIT) self.assertNotIsInstance(response, ErrorResponse) self.assertEqual(request.message_id, response.request_message_id) service_client.unregister_service_sync(reg_info, self.DEFAULT_TIMEOUT) self.assertEqual(service_registration_count, request_received_count[0])
def test_current_request(self): uid = UuidGenerator.generate_id_as_string() self.rm.add_current_request(uid) self.assertEquals(1, self.rm.get_current_request_queue_size()) self.assertTrue(uid in self.rm.current_request_message_ids) self.rm.remove_current_request(uid) self.assertEquals(0, self.rm.get_current_request_queue_size()) self.assertFalse(uid in self.rm.current_request_message_ids)
def test_subscribe_and_unsubscribe(self): with self.create_client(max_retries=0) as client: client.connect() topic = UuidGenerator.generate_id_as_string() client.subscribe(topic) self.assertIn(topic, client.subscriptions) client.unsubscribe(topic) self.assertNotIn(topic, client.subscriptions)
def test_client_raises_exception_when_cannot_sync_connect_to_broker(self): with self.create_client() as client: broker = Broker("localhost", UuidGenerator.generate_id_as_string(), "127.0.0.1") client._config.brokers = [broker] with self.assertRaises(DxlException): client.connect()
def test_round_robin_services(self): service_count = 10 request_per_service_count = 10 request_to_send_count = service_count * request_per_service_count request_received_count = [0] request_to_wrong_service_id_count = [0] requests_by_service = {} request_lock = threading.Lock() topic = UuidGenerator.generate_id_as_string() with self.create_client() as service_client: service_client.connect() def my_request(callback_service_id, request): with request_lock: request_received_count[0] += 1 if request.service_id and \ (request.service_id != callback_service_id): request_to_wrong_service_id_count[0] += 1 if request.service_id in requests_by_service: requests_by_service[request.service_id] += 1 else: requests_by_service[request.service_id] = 1 response = Response(request) service_client.send_response(response) def create_service_reg_info(): reg_info = ServiceRegistrationInfo(service_client, "round_robin_service") callback = RequestCallback() callback.on_request = \ lambda request: my_request(reg_info.service_id, request) reg_info.add_topic(topic, callback) service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) return reg_info reg_infos = [create_service_reg_info() # pylint: disable=unused-variable for _ in range(service_count)] with self.create_client() as request_client: request_client.connect() for _ in range(0, request_to_send_count): request = Request(topic) response = request_client.sync_request( request, timeout=self.RESPONSE_WAIT) self.assertNotIsInstance(response, ErrorResponse) self.assertEqual(request.message_id, response.request_message_id) with request_lock: self.assertEqual(0, request_to_wrong_service_id_count[0]) self.assertEqual(request_to_send_count, request_received_count[0]) self.assertEqual(service_count, len(requests_by_service)) for service_request_count in requests_by_service.values(): self.assertEqual(request_per_service_count, service_request_count)
def test_event_with_empty_broker_and_client_guids(self): source_client_guid = UuidGenerator.generate_id_as_string() source_broker_guid = UuidGenerator.generate_id_as_string() event = Event(destination_topic="") event._source_client_id = source_client_guid event._source_broker_id = source_broker_guid event.payload = "EVENT".encode() PP.pprint(vars(event)) message = event._to_bytes() PP.pprint(message) result = Message._from_bytes(message) PP.pprint(vars(result)) self.assertTrue(isinstance(result.broker_ids, list)) self.assertTrue(isinstance(result.client_ids, list))
def test_unsubscribe_for_unknown_topic_does_not_raise_error(self): with self.create_client(max_retries=0) as client: client.connect() topic = UuidGenerator.generate_id_as_string() client.subscribe(topic) self.assertIn(topic, client.subscriptions) client.unsubscribe(topic) client.unsubscribe(topic) self.assertNotIn(topic, client.subscriptions)
def test_multiple_services(self): with self.create_client() as service_client: service_client.connect() reg_info_topic_1 = "multiple_services_test_1_" + \ UuidGenerator.generate_id_as_string() reg_info_1 = ServiceRegistrationInfo( service_client, "multiple_services_test_1") def reg_info_request_1(request): response = Response(request) response.payload = "service1" service_client.send_response(response) reg_info_callback_1 = RequestCallback() reg_info_callback_1.on_request = reg_info_request_1 reg_info_1.add_topic(reg_info_topic_1, reg_info_callback_1) service_client.register_service_sync(reg_info_1, self.DEFAULT_TIMEOUT) reg_info_topic_2 = "multiple_services_test_2_" + \ UuidGenerator.generate_id_as_string() reg_info_2 = ServiceRegistrationInfo( service_client, "multiple_services_test_2") def reg_info_request_2(request): response = Response(request) response.payload = "service2" service_client.send_response(response) reg_info_callback_2 = RequestCallback() reg_info_callback_2.on_request = reg_info_request_2 reg_info_2.add_topic(reg_info_topic_2, reg_info_callback_2) service_client.register_service_sync(reg_info_2, self.DEFAULT_TIMEOUT) with self.create_client() as request_client: request_client.connect() response = request_client.sync_request( Request(reg_info_topic_1), self.DEFAULT_TIMEOUT) self.assertIsInstance(response, Response) self.assertEqual(response.payload.decode("utf8"), "service1") response = request_client.sync_request( Request(reg_info_topic_2), self.DEFAULT_TIMEOUT) self.assertIsInstance(response, Response) self.assertEqual(response.payload.decode("utf8"), "service2")
def execute_subs__unsubs_test(self): with self.create_client(max_retries=0) as client: try: client.connect() topic = UuidGenerator.generate_id_as_string() client.subscribe(topic) time.sleep(0.5) client.unsubscribe(topic) client.disconnect() except Exception, e: print e.message
def test_response_service_not_found_no_service_id_at_client(self): request_received = [False] topic = UuidGenerator.generate_id_as_string() with self.create_client() as service_client: service_client.connect() def my_request(request): request_received[0] = True service_client.send_response(Response(request)) reg_info = ServiceRegistrationInfo( service_client, "response_service_not_found_no_service_id_at_client_test") callback = RequestCallback() callback.on_request = my_request reg_info.add_topic(topic, callback) reg_info.add_topic(topic, callback) service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) self.assertIsNotNone( self.query_service_registry_by_service( service_client, reg_info)) with self.create_client() as request_client: request_client.connect() # Remove the service's registration with the client-side # ServiceManager, avoiding unregistration of the service from # the broker. This should allow the broker to forward the # request on to the service client. registered_services = service_client._service_manager.services service = registered_services[reg_info.service_id] del registered_services[reg_info.service_id] request = Request(topic) response = request_client.sync_request( request, timeout=self.RESPONSE_WAIT) # Re-register the service with the internal ServiceManager so # that its resources (TTL timeout, etc.) can be cleaned up # properly at shutdown. registered_services[reg_info.service_id] = service # The request should receive an 'unavailable service' error # response because the service client should be unable to route # the request to an internally registered service. self.assertFalse(request_received[0]) self.assertIsInstance(response, ErrorResponse) self.assertEqual(reg_info.service_id, response.service_id) self.assertEqual( self.DXL_SERVICE_UNAVAILABLE_ERROR_CODE, BrokerServiceRegistryTest.normalized_error_code(response)) self.assertEqual(self.DXL_SERVICE_UNAVAILABLE_ERROR_MESSAGE, response.error_message) self.assertIsNone(self.query_service_registry_by_service( service_client, reg_info))
def test_execute_message_payload(self): # Create a server that handles a request, unpacks the payload, and # asserts that the information in the payload was delivered successfully. with self.create_client(max_retries=0) as server: test_service = TestService(server, 1) server.connect() topic = UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( server, "message_payload_runner_service") # callback definition def on_request(request): unpacker = Unpacker( file_like=StringIO.StringIO(request.payload)) with self.request_complete_condition: try: self.assertEquals(unpacker.next(), self.TEST_STRING) self.assertEquals(unpacker.next(), self.TEST_BYTE) self.assertEquals(unpacker.next(), self.TEST_INT) self.received_request = True except Exception, e: print e.message self.request_complete_condition.notify_all() request_callback = RequestCallback() request_callback.on_request = on_request reg_info.add_topic(topic, request_callback) # Register the service server.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) with self.create_client() as client: client.connect() packer = Packer() # Send a request to the server with information contained # in the payload request = Request(destination_topic=topic) request.payload = packer.pack(self.TEST_STRING) request.payload += packer.pack(self.TEST_BYTE) request.payload += packer.pack(self.TEST_INT) client.async_request(request, request_callback) with self.request_complete_condition: if not self.received_request: # Wait until the request has been processed self.request_complete_condition.wait(self.MAX_WAIT) if not self.received_request: self.fail("Request not received.")
def test_execute_message_payload(self): # Create a server that handles a request, unpacks the payload, and # asserts that the information in the payload was delivered successfully. with self.create_client(max_retries=0) as service_client: service_client.connect() topic = UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( service_client, "message_payload_runner_service") # callback definition def on_request(request): with self.request_complete_condition: try: self.request_received = request except Exception as ex: # pylint: disable=broad-except print(ex) self.request_complete_condition.notify_all() request_callback = RequestCallback() request_callback.on_request = on_request reg_info.add_topic(topic, request_callback) # Register the service service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) with self.create_client() as request_client: request_client.connect() packer = msgpack.Packer() # Send a request to the server with information contained # in the payload request = Request(destination_topic=topic) request.payload = packer.pack(self.TEST_STRING) request.payload += packer.pack(self.TEST_BYTE) request.payload += packer.pack(self.TEST_INT) request_client.async_request(request, request_callback) start = time.time() # Wait until the request has been processed with self.request_complete_condition: while (time.time() - start < self.MAX_WAIT) and \ not self.request_received: self.request_complete_condition.wait(self.MAX_WAIT) self.assertIsNotNone(self.request_received) unpacker = msgpack.Unpacker(file_like=BytesIO(request.payload)) self.assertEqual( next(unpacker).decode('utf8'), self.TEST_STRING) self.assertEqual(next(unpacker), self.TEST_BYTE) self.assertEqual(next(unpacker), self.TEST_INT)
def test_request(self): reply_to_channel = "/mcafee/client/" + UuidGenerator.generate_id_as_string() service_guid = UuidGenerator.generate_id_as_string() source_client_guid = UuidGenerator.generate_id_as_string() source_broker_guid = UuidGenerator.generate_id_as_string() request = Request(destination_topic="") request.reply_to_topic = reply_to_channel request.service_id = service_guid request._source_client_id = source_client_guid request._source_broker_id = source_broker_guid request.broker_ids = ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] request.client_ids = ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] request.payload = str.encode("REQUEST") pp.pprint(vars(request)) message = request._to_bytes() pp.pprint(message) result = Message._from_bytes(message) pp.pprint(vars(result)) assert result.reply_to_topic == reply_to_channel assert result.service_id == service_guid assert result.source_client_id == source_client_guid assert result.source_broker_id == source_broker_guid assert result.broker_ids == ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] assert result.client_ids == ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] assert result.payload == str.encode("REQUEST") assert result.message_type == Message.MESSAGE_TYPE_REQUEST
def test_subs_count(self): clients = [] with self.create_client() as client: client.connect() for i in range(6): c = self.create_client() c.connect() clients.append(c) random1 = UuidGenerator.generate_id_as_string() random2 = UuidGenerator.generate_id_as_string() topic1 = "/foo/bar/" + random1 + "/" + random2 clients[0].subscribe(topic1) clients[1].subscribe(topic1) clients[2].subscribe(topic1) clients[3].subscribe("/foo/bar/" + random1 + "/#") clients[4].subscribe("/foo/+/" + random1 + "/#") topic2 = "/foo/baz/" + random2 clients[1].subscribe(topic2) clients[2].subscribe(topic2) clients[5].subscribe("#") # Topic 1 req = self._create_request(topic1) resp = client.sync_request(req, 5) pl = str(resp.payload) self.assertTrue(":6}" in pl) # Topic 2 req = self._create_request(topic2) resp = client.sync_request(req, 5) pl = str(resp.payload) self.assertTrue(":3}" in pl) print "Test passed!"
def test_request_and_response(self): reply_to_channel = "/mcafee/client/" + UuidGenerator.generate_id_as_string() service_guid = UuidGenerator.generate_id_as_string() source_client_guid = UuidGenerator.generate_id_as_string() source_broker_guid = UuidGenerator.generate_id_as_string() request = Request(destination_topic="") request.reply_to_channel = reply_to_channel request.service_id = service_guid request._source_client_id = source_client_guid request._source_broker_id = source_broker_guid request.broker_ids = ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] request.client_ids = ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] request.payload = "REQUEST".encode() PP.pprint(vars(request)) message = request._to_bytes() PP.pprint(message) self.assertEqual(source_client_guid, request.source_client_id) result = Message._from_bytes(message) PP.pprint(vars(result)) response = Response(request=request) response.payload = "RESPONSE".encode() PP.pprint(vars(response)) message = response._to_bytes() PP.pprint(message) result = Message._from_bytes(message) PP.pprint(vars(result)) self.assertEqual(Message.MESSAGE_TYPE_RESPONSE, result.message_type)
def test_client_retries_defines_how_many_times_the_client_retries_connection(self, retries, connect_count): # Client wont' connect ;) self.client._client.connect = Mock(side_effect=Exception('Could not connect')) # No delay between retries (faster unit tests) self.client.config.reconnect_delay = 0 self.client._wait_for_policy_delay = 0 broker = Broker(host_name='localhost') broker._parse(UuidGenerator.generate_id_as_string() + ";9999;localhost;127.0.0.1") self.client.config.brokers = [broker] self.client.config.connect_retries = retries with self.assertRaises(DxlException): self.client.connect() self.assertEqual(self.client._client.connect.call_count, connect_count)
def test_client_receives_error_response_on_request_to_unknown_service(self): """ The idea of this test is to send a sync request to an unknown service and get a "unable to locate service" error response. """ with self.create_client() as client: test_topic = '/test/doesntexists/' + client.config._client_id client.connect() time.sleep(2) self.assertTrue(client.connected) # Send request thru dxl fabric to a service which doesn't exists msg = Request(destination_topic=test_topic) msg.service_id = UuidGenerator.generate_id_as_string() response = client.sync_request(msg, 1) # Check that we have an error response for our request self.assertTrue(isinstance(response, ErrorResponse)) self.assertEqual(response.service_id, msg.service_id)
def test_execute_events(self): with self.create_client(max_retries=0) as client: try: client.connect() topic = UuidGenerator.generate_id_as_string() # Create and register an event callback. Ensure that all sent events are received # (via the outstanding events set). Also, track the number of total events received. def event_callback(event): with self.event_condition: # Increment count of responses received self.event_count += 1 # Remove from outstanding events self.remove_outstanding_event(event.message_id) # Notify that a response has been received (are we done yet?) self.event_condition.notify_all() callback = EventCallback() callback.on_event = event_callback client.add_event_callback(topic, callback) for _ in range(0, self.EVENT_COUNT): event = Event(topic) self.append_outstanding_event(event.message_id) client.send_event(event) with self.event_condition: while self.event_count != self.EVENT_COUNT: current_count = self.event_count self.event_condition.wait(self.MAX_EVENT_WAIT) if current_count == self.event_count: self.fail("Event wait timeout.") self.assertEqual(0, len(self.outstanding_events)) print("Events test: PASSED") except Exception as ex: print(ex) raise ex
def test_execute_message_other_fields(self): with self.create_client(max_retries=0) as client: client.connect() topic = UuidGenerator.generate_id_as_string() def on_event(event): with self.event_received_condition: try: self.event_received = event except Exception as ex: # pylint: disable=broad-except print(ex) self.event_received_condition.notify_all() event_callback = EventCallback() event_callback.on_event = on_event client.add_event_callback(topic, event_callback) event = Event(destination_topic=topic) event.other_fields = {"key" + str(i): "value" + str(i) for i in range(self.OTHER_FIELDS_COUNT)} event.other_fields[b"key_as_bytes"] = b"val_as_bytes" client.send_event(event) # Bytes values for other field keys/values are expected to be # converted to unicode strings as received from the DXL fabric. del event.other_fields[b"key_as_bytes"] event.other_fields[u"key_as_bytes"] = u"val_as_bytes" start = time.time() with self.event_received_condition: while (time.time() - start < self.MAX_WAIT) and \ not self.event_received: self.event_received_condition.wait(self.MAX_WAIT) self.assertIsNotNone(self.event_received) self.assertIsNotNone(self.event_received.other_fields) for i in range(self.OTHER_FIELDS_COUNT): self.assertEqual( event.other_fields["key" + str(i)], self.event_received.other_fields.get("key" + str(i), "")) self.assertEqual(event.other_fields["key_as_bytes"], self.event_received.other_fields.get( "key_as_bytes", ""))