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()