def setUp(self): """ Starts a framework in separate process to advertise a helloimpl remote service. Then starts a local framework to register the TestEndpointEventListener """ print("EtcdDiscoveryListenerTest etcd_hostname={0},toppath={1}".format( TEST_ETCD_HOSTNAME, TEST_ETCD_TOPPATH)) # start external framework that publishes remote service self.status_queue = Queue() self.publisher_process = WrappedProcess( target=start_framework_for_advertise, args=[self.status_queue]) self.publisher_process.start() state = self.status_queue.get(10) self.assertEqual(state, "ready") # start a local framework self.framework = create_framework( [ "pelix.ipopo.core", "pelix.rsa.remoteserviceadmin", # RSA implementation "tests.rsa.endpoint_event_listener", "pelix.rsa.providers.discovery.discovery_etcd", ], { "etcd.hostname": TEST_ETCD_HOSTNAME, "etcd.toppath": TEST_ETCD_TOPPATH, }, ) self.framework.start() # Start the framework and return TestEndpointEventListener context = self.framework.get_bundle_context() # Start an HTTP server, required by XML-RPC with use_ipopo(context) as ipopo: # create endpoint event listener self.listener = ipopo.instantiate( "etcd-test-endpoint-event-listener-factory", "etcd-test-endpoint-event-listener", { TopologyManager.ENDPOINT_LISTENER_SCOPE: ENDPOINT_LISTENER_SCOPE }, )
def _run_test(self, transport_bundle, exporter_factory, importer_factory, test_kwargs=True): """ Runs a remote service call test :param transport_bundle: Transport implementation bundle to use :param exporter_factory: Name of the RS exporter factory :param importer_factory: Name of the RS importer factory :param test_kwargs: Test keyword arguments :raise queue.Empty: Peer took to long to answer :raise ValueError: Test failed """ # Define components components = [(exporter_factory, "rs-exporter"), (importer_factory, "rs-importer")] # Start the remote framework status_queue = Queue() peer = WrappedProcess(target=self._export_framework, args=(status_queue, transport_bundle, components)) peer.start() try: # Wait for the ready state state = status_queue.get(4) self.assertEqual(state, "ready") # Load the local framework (after the fork) framework = self._load_framework(transport_bundle, components) context = framework.get_bundle_context() # Look for the remote service for _ in range(10): svc_ref = context.get_service_reference(SVC_SPEC) if svc_ref is not None: break time.sleep(.5) else: self.fail("Remote Service not found") # Get it svc = context.get_service(svc_ref) # Dummy call result = svc.dummy() state = status_queue.get(2) self.assertEqual(state, "call-dummy") self.assertIsNone(result, "Dummy didn't returned None: {0}".format(result)) # Echo call for value in (None, "Test", 42, [1, 2, 3], {"a": "b"}): result = svc.echo(value) # Check state state = status_queue.get(2) self.assertEqual(state, "call-echo") # Check result self.assertEqual(result, value) if test_kwargs: # Keyword arguments sample_text = "SomeSampleText" # Test as-is with default arguments result = svc.keywords(text=sample_text) state = status_queue.get(2) self.assertEqual(state, "call-keyword") self.assertEqual(result, sample_text.upper()) # Test with keywords in the same order as positional arguments result = svc.keywords(text=sample_text, to_lower=True) state = status_queue.get(2) self.assertEqual(state, "call-keyword") self.assertEqual(result, sample_text.lower()) result = svc.keywords(text=sample_text, to_lower=False) state = status_queue.get(2) self.assertEqual(state, "call-keyword") self.assertEqual(result, sample_text.upper()) # Test with keywords in a different order # than positional arguments result = svc.keywords(to_lower=True, text=sample_text) state = status_queue.get(2) self.assertEqual(state, "call-keyword") self.assertEqual(result, sample_text.lower()) # Exception handling try: svc.error() except: # The error has been propagated state = status_queue.get(2) self.assertEqual(state, "call-error") else: self.fail("No exception raised calling 'error'") # Call undefined method try: svc.undefined() except: # The error has been propagated: OK pass else: self.fail("No exception raised calling an undefined method") # Stop the peer svc.stop() # Wait for the peer to stop state = status_queue.get(2) self.assertEqual(state, "stopping") # Wait a bit more, to let coverage save its files time.sleep(.1) finally: # Stop everything (and delete the framework in any case FrameworkFactory.delete_framework() peer.terminate() status_queue.close()
def _run_test(self, discovery_bundle, discovery_factory, discovery_opts=None): """ Runs a remote service call test :param discovery_bundle: Discovery implementation bundle to use :param discovery_factory: Name of the discovery factory :param discovery_opts: Initial parameters of the discovery component :raise queue.Empty: Peer took to long to answer :raise ValueError: Test failed """ transport_bundle = "pelix.remote.json_rpc" # Define components components = [ (pelix.remote.FACTORY_TRANSPORT_JSONRPC_EXPORTER, "rs-exporter"), (pelix.remote.FACTORY_TRANSPORT_JSONRPC_IMPORTER, "rs-importer"), (discovery_factory, "discovery", discovery_opts) ] # Start the remote framework status_queue = Queue() peer = WrappedProcess(target=self._export_framework, args=(status_queue, transport_bundle, discovery_bundle, components)) peer.start() try: # Wait for the ready state state = status_queue.get(4) self.assertEqual(state, "ready") # Load the local framework (after the fork) framework = self._load_framework(transport_bundle, discovery_bundle, components) context = framework.get_bundle_context() # Look for the remote service for _ in range(10): svc_ref = context.get_service_reference(SVC_SPEC) if svc_ref is not None: break time.sleep(.5) else: self.fail("Remote Service not found") # Get it svc = context.get_service(svc_ref) # Echo call for value in (None, "Test", 42, [1, 2, 3], {"a": "b"}): result = svc.echo(value) # Check state state = status_queue.get(2) self.assertEqual(state, "call-echo") # Check result self.assertEqual(result, value) # Stop the peer svc.stop() # Wait for the peer to stop state = status_queue.get(2) self.assertEqual(state, "stopping") # Wait a bit more, to let coverage save its files peer.join(1) # Check the remote service # Look for the remote service for _ in range(10): svc_ref = context.get_service_reference(SVC_SPEC) if svc_ref is None: break time.sleep(2) else: self.fail("Remote Service still registered") finally: # Stop everything (and delete the framework in any case try: FrameworkFactory.delete_framework() except: pass peer.terminate() status_queue.close()