class TestPluginManagerBase(unittest.TestCase): """ Commen functionalities used my many test cases """ pm_proc = None @classmethod def setUpClass(cls): # start the plugin manger in another process so that we can connect to it using its broker interface cls.pm_proc = Process(target=SonPluginManager) cls.pm_proc.daemon = True cls.pm_proc.start() time.sleep(1) # give the plugin manager some time to start @classmethod def tearDownClass(cls): if cls.pm_proc is not None: cls.pm_proc.terminate() del cls.pm_proc def setUp(self): # initialize messaging subsystem self.m = ManoBrokerRequestResponseConnection("pm-client" + self.id()) self.wait_for_reply = Event() self.plugin_uuid = None def tearDown(self): self.m.stop_connection() def waitForMessage(self, timeout=5): self.wait_for_reply.clear() if not self.wait_for_reply.wait(timeout): raise Exception("Timeout in wait for reply message.") def messageReceived(self): self.wait_for_reply.set() def register(self): """ Helper: We need this in many tests. :return: """ # do the registration call response = self.m.call_sync( "platform.management.plugin.register", { "name": "test-plugin", "version": "v0.01", "description": "description" }, ) assert response is not None msg = response.payload assert msg["status"] == "OK" assert len(msg["uuid"]) > 0 assert msg["error"] is None # set internal state variables self.plugin_uuid = msg["uuid"] def deregister(self): """ Helper: We need this in many tests. :return: """ assert self.plugin_uuid is not None response = self.m.call_sync("platform.management.plugin.deregister", {"uuid": self.plugin_uuid}) assert response is not None assert {"status": "OK"} == response.payload
class test_SMR_functionalities(unittest.TestCase): @classmethod def setUpClass(self): self.smr_proc = Process(target=SpecificManagerRegistry) self.smr_proc.daemon = True self.manoconn = ManoBrokerRequestResponseConnection( 'son-plugin.SpecificManagerRegistry') self.wait_for_ssm_event = threading.Event() self.wait_for_ssm_event.clear() self.wait_for_fsm_event = threading.Event() self.wait_for_fsm_event.clear() self.event1 = False self.event2 = False self.smr_proc.start() time.sleep(4) @classmethod def tearDownClass(self): if self.smr_proc is not None: self.smr_proc.terminate() del self.smr_proc try: self.manoconn.stop_connection() except Exception as e: LOG.exception("Stop connection exception.") del self.wait_for_fsm_event del self.wait_for_ssm_event def ssm_eventFinished(self): self.wait_for_ssm_event.set() def waitForSSMEvent(self, timeout=5, msg="Event timed out."): if not self.wait_for_ssm_event.wait(timeout): self.assertEqual(True, False, msg=msg) def fsm_eventFinished(self): self.wait_for_fsm_event.set() def waitForFSMEvent(self, timeout=5, msg="Event timed out."): if not self.wait_for_fsm_event.wait(timeout): self.assertEqual(True, False, msg=msg) def test_1_SMR_onboard(self): self.event1 = False self.event2 = False def on_ssm_onboarding_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) self.assertTrue( list(result.keys()) == ['sonssmservice1dumb1', 'sonssmservice1placement1'] or list(result.keys()) == ['sonssmservice1placement1', 'sonssmservice1dumb1'], msg='not all SSMs results received') self.assertTrue( result['sonssmservice1dumb1']['status'] == 'On-boarded', msg='error in onbording sonssmservice1dumb1') self.assertTrue( result['sonssmservice1dumb1']['error'] == 'None', msg='error in onbording sonssmservice1dumb1') self.assertTrue(result['sonssmservice1placement1']['status'] == 'On-boarded', msg='error in onbording sonssmservice1dumb1') self.assertTrue( result['sonssmservice1placement1']['error'] == 'None', msg='error in onbording sonssmservice1placement1') self.ssm_eventFinished() def on_fsm_onboarding_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) if list(result.keys()) == ['sonfsmservice1function1dumb1']: self.assertTrue( list( result.keys()) == ['sonfsmservice1function1dumb1'], msg='not all FSMs results in VNFD1 received') self.assertTrue( result['sonfsmservice1function1dumb1']['status'] == 'On-boarded', msg='error in onbording sonssmservice1dumb1') self.assertTrue( result['sonfsmservice1function1dumb1']['error'] == 'None', msg='error in onbording sonfsmservice1function1dumb1') self.event1 = True else: self.assertTrue( list(result.keys()) == [ 'sonfsmservice1function1monitoring1', 'sonfsmservice1firewallconfiguration1' ] or list(result.keys()) == [ 'sonfsmservice1firewallconfiguration1', 'sonfsmservice1function1monitoring1' ], msg='not all FSMs results in VNFD2 received') self.assertTrue( result['sonfsmservice1function1monitoring1']['status'] == 'On-boarded', msg='error in onbording sonssmservice1dumb1') self.assertTrue( result['sonfsmservice1function1monitoring1']['error'] == 'None', msg= 'error in onbording sonfsmservice1function1monitoring1' ) self.assertTrue( result['sonfsmservice1firewallconfiguration1'] ['status'] == 'On-boarded', msg='error in onbording sonssmservice1dumb1') self.assertTrue( result['sonfsmservice1firewallconfiguration1']['error'] == 'None', msg= 'error in onbording sonfsmservice1firewallconfiguration1' ) self.event2 = True if self.event1 and self.event2 == True: self.fsm_eventFinished() self.manoconn.subscribe(on_ssm_onboarding_result, 'specific.manager.registry.ssm.on-board') self.manoconn.subscribe(on_fsm_onboarding_result, 'specific.manager.registry.fsm.on-board') onboaring_proc = Process(target=fakeslm_onboarding) onboaring_proc.daemon = True onboaring_proc.start() self.waitForSSMEvent(timeout=70, msg='SSM Onboarding request not received.') self.waitForFSMEvent(timeout=70, msg='FSM Onboarding request not received.') self.wait_for_fsm_event.clear() self.wait_for_ssm_event.clear() onboaring_proc.terminate() del onboaring_proc def test_2_SMR_instantiation(self): self.event1 = False self.event2 = False def on_ssm_instantiation_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) self.assertTrue( list(result.keys()) == ['sonssmservice1dumb1', 'sonssmservice1placement1'] or list(result.keys()) == ['sonssmservice1placement1', 'sonssmservice1dumb1'], msg='not all SSMs results received') self.assertTrue( result['sonssmservice1dumb1']['status'] == 'Instantiated', msg='error in instantiation sonssmservice1dumb1') self.assertTrue( result['sonssmservice1dumb1']['error'] == 'None', msg='error in instantiation sonssmservice1dumb1') self.assertTrue( result['sonssmservice1placement1']['status'] == 'Instantiated', msg='error in instantiation sonssmservice1placement1') self.assertTrue( result['sonssmservice1placement1']['error'] == 'None', msg='error in instantiation sonssmservice1placement1') self.ssm_eventFinished() def on_fsm_instantiation_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) if list(result.keys()) == ['sonfsmservice1function1dumb1']: self.assertTrue( list( result.keys()) == ['sonfsmservice1function1dumb1'], msg= 'not all FSMs instantiation results in VNFD1 received') self.assertTrue( result['sonfsmservice1function1dumb1']['status'] == 'Instantiated', msg= 'error in instantiation sonfsmservice1function1dumb1') self.assertTrue( result['sonfsmservice1function1dumb1']['error'] == 'None', msg= 'error in instantiation sonfsmservice1function1dumb1') self.event1 = True else: self.assertTrue( list(result.keys()) == [ 'sonfsmservice1function1monitoring1', 'sonfsmservice1firewallconfiguration1' ] or list(result.keys()) == [ 'sonfsmservice1firewallconfiguration1', 'sonfsmservice1function1monitoring1' ], msg= 'not all FSMs instantiation results in VNFD2 received') self.assertTrue( result['sonfsmservice1function1monitoring1']['status'] == 'Instantiated', msg= 'error in instantiation sonfsmservice1function1monitoring1' ) self.assertTrue( result['sonfsmservice1function1monitoring1']['error'] == 'None', msg= 'error in instantiation sonfsmservice1function1monitoring1' ) self.assertTrue( result['sonfsmservice1firewallconfiguration1'] ['status'] == 'Instantiated', msg= 'error in instantiation sonfsmservice1firewallconfiguration1' ) self.assertTrue( result['sonfsmservice1firewallconfiguration1']['error'] == 'None', msg= 'error in instantiation sonfsmservice1firewallconfiguration1' ) self.event2 = True if self.event1 and self.event2: self.fsm_eventFinished() self.manoconn.subscribe(on_ssm_instantiation_result, 'specific.manager.registry.ssm.instantiate') self.manoconn.subscribe(on_fsm_instantiation_result, 'specific.manager.registry.fsm.instantiate') instantiation_proc = Process(target=fakeslm_instantiation) instantiation_proc.daemon = True instantiation_proc.start() self.waitForSSMEvent(timeout=70, msg='SSM instantiation request not received.') self.waitForFSMEvent(timeout=70, msg='FSM instantiation request not received.') self.wait_for_ssm_event.clear() self.wait_for_fsm_event.clear() instantiation_proc.terminate() del instantiation_proc def test_3_SMR_update(self): def on_ssm_updating_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) self.assertTrue(list(result.keys()) == ['sonssmservice1dumb1'], msg='not all SSMs results received') self.assertTrue( result['sonssmservice1dumb1']['status'] == 'Updated', msg='error in updating status filed sonssmservice1dumb1') self.assertTrue( result['sonssmservice1dumb1']['error'] == 'None', msg='error in updating error filed sonssmservice1dumb1') self.ssm_eventFinished() def on_fsm_updating_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) self.assertTrue( list(result.keys()) == [ 'sonfsmservice1function1updateddumb1' ], msg='not all FSMs updating results in VNFD2 received') self.assertTrue( result['sonfsmservice1function1updateddumb1']['status'] == 'Updated', msg='error in updating sonfsmservice1function1monitoring1') self.assertTrue( result['sonfsmservice1function1updateddumb1']['error'] == 'None', msg='error in updating sonfsmservice1function1monitoring1') self.fsm_eventFinished() self.manoconn.subscribe(on_ssm_updating_result, 'specific.manager.registry.ssm.update') self.manoconn.subscribe(on_fsm_updating_result, 'specific.manager.registry.fsm.update') updating_proc = Process(target=fakeslm_updating) updating_proc.daemon = True updating_proc.start() self.waitForSSMEvent(timeout=70, msg='SSM updating request not received.') self.waitForFSMEvent(timeout=70, msg='FSM updating request not received.') self.wait_for_fsm_event.clear() self.wait_for_ssm_event.clear() updating_proc.terminate() del updating_proc def test_4_SMR_terminate(self): self.event1 = False self.event2 = False def on_ssm_termination_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) self.assertTrue( list(result.keys()) == ['sonssmservice1dumb1', 'sonssmservice1placement1'] or ['sonssmservice1placement1', 'sonssmservice1dumb1'], msg='not all SSMs results received') self.assertTrue( result['sonssmservice1dumb1']['status'] == 'Terminated', msg='error in termination status field sonssmservice1dumb1' ) self.assertTrue( result['sonssmservice1dumb1']['error'] == 'None', msg='error in termination error field sonssmservice1dumb1') self.assertTrue( result['sonssmservice1placement1']['status'] == 'Terminated', msg= 'error in termination status field sonssmservice1placement1' ) self.assertTrue( result['sonssmservice1placement1']['error'] == 'None', msg= 'error in termination error field sonssmservice1placement1' ) self.ssm_eventFinished() def on_fsm_termination_result(ch, method, properties, message): if properties.app_id == 'son-plugin.SpecificManagerRegistry': result = yaml.load(message) if list(result.keys()) == ['sonfsmservice1function1dumb1']: self.assertTrue( result['sonfsmservice1function1dumb1']['status'] == 'Terminated', msg= 'error in termination status field sonfsmservice1function1dumb1' ) self.assertTrue( result['sonfsmservice1function1dumb1']['error'] == 'None', msg= 'error in termination error field sonfsmservice1function1dumb1' ) self.event1 = True else: self.assertTrue( list(result.keys()) == [ 'sonfsmservice1function1monitoring1', 'sonfsmservice1function1updateddumb1' ] or list(result.keys()) == [ 'sonfsmservice1function1updateddumb1', 'sonfsmservice1function1monitoring1' ], msg= 'not all FSMs Termination results in vnfdt2 received') self.assertTrue( result['sonfsmservice1function1monitoring1']['status'] == 'Terminated', msg= 'error in termination status field sonfsmservice1function1monitoring1' ) self.assertTrue( result['sonfsmservice1function1monitoring1']['error'] == 'None', msg= 'error in termination error field sonfsmservice1function1monitoring1' ) self.assertTrue( result['sonfsmservice1function1updateddumb1']['status'] == 'Terminated', msg= 'error in termination status field sonfsmservice1function1updateddumb1' ) self.assertTrue( result['sonfsmservice1function1updateddumb1']['error'] == 'None', msg= 'error in termination error field sonfsmservice1function1updateddumb1' ) self.event2 = True self.fsm_eventFinished() if self.event1 and self.event2: self.fsm_eventFinished() self.manoconn.subscribe(on_ssm_termination_result, 'specific.manager.registry.ssm.terminate') self.manoconn.subscribe(on_fsm_termination_result, 'specific.manager.registry.fsm.terminate') termination_proc = Process(target=fakeslm_termination) termination_proc.daemon = True termination_proc.start() self.waitForSSMEvent(timeout=70, msg='SSM termination request not received.') self.waitForFSMEvent(timeout=70, msg='FSM termination request not received.') self.wait_for_fsm_event.clear() self.wait_for_ssm_event.clear() termination_proc.terminate() del termination_proc
class testPLEXRegistration(unittest.TestCase): """ Tests the registration process of the Placement Executive to the broker and the plugin manager, and the heartbeat process. """ def setUp(self): #a new Placement Executive in another process for each test self.plex_proc = Process(target=PlacementExecutive) self.plex_proc.daemon = True if 'broker_man_host' in os.environ: self.man_host = os.environ['broker_man_host'] else: self.man_host = 'http://localhost:15672' if 'sm_broker_host' in os.environ: self.sm_host = os.environ['sm_broker_host'] else: self.sm_host = 'http://localhost:15672' url_user = "******".format(self.man_host) url_create = '{0}/api/vhosts/ssm-1234'.format(self.man_host) url_permission = '{0}/api/permissions/ssm-1234/specific-management'.format( self.man_host) self.headers = {'content-type': 'application/json'} data1 = '{"password":"******","tags":"son-sm"}' data2 = '{"configure":".*","write":".*","read":".*"}' res = requests.put(url=url_user, headers=self.headers, data=data1, auth=('guest', 'guest')) LOG.info(res.content) res1 = requests.put(url=url_create, headers=self.headers, auth=('guest', 'guest')) LOG.info(res1.content) res2 = requests.put(url=url_permission, headers=self.headers, data=data2, auth=('guest', 'guest')) LOG.info(res2.content) #make a new connection with the broker before each test url = "{0}/ssm-1234".format(self.sm_host) self.manoconn = ManoBrokerRequestResponseConnection( 'son-plugin.SonPluginManager') self.sm_connection = ManoBrokerRequestResponseConnection( 'son-plugin.SSM', url=url) #Some threading events that can be used during the tests self.wait_for_event1 = threading.Event() self.wait_for_event1.clear() self.wait_for_event2 = threading.Event() self.wait_for_event2.clear() def tearDown(self): #Killing the Placement Executive if self.plex_proc is not None: self.plex_proc.terminate() del self.plex_proc #Killing the connection with the broker try: self.manoconn.stop_connection() self.sm_connection.stop_connection() except Exception as e: LOG.exception("Stop connection exception.") #Clearing the threading helpers del self.wait_for_event1 del self.wait_for_event2 url_user = "******".format(self.man_host) url_vhost = "{0}/api/vhosts/ssm-1234".format(self.man_host) res1 = requests.delete(url=url_user, headers=self.headers, auth=('guest', 'guest')) LOG.info(res1.content) res1 = requests.delete(url=url_vhost, headers=self.headers, auth=('guest', 'guest')) LOG.info(res1.content) #Method that terminates the timer that waits for an event def eventFinished1(self): self.wait_for_event1.set() def eventFinished2(self): self.wait_for_event2.set() #Method that starts a timer, waiting for an event def waitForEvent1(self, timeout=5, msg="Event timed out."): if not self.wait_for_event1.wait(timeout): self.assertEqual(True, False, msg=msg) def waitForEvent2(self, timeout=5, msg="Event timed out."): if not self.wait_for_event2.wait(timeout): self.assertEqual(True, False, msg=msg) def test_1_PLEX_Registration(self): """ TEST: This test verifies whether the Placement Executive is sending out a message, and whether it contains all the needed info on the platform.management.plugin.register topic to register to the plugin manager. """ #STEP3a: When receiving the message, we need to check whether all fields present. def on_register_receive(ch, method, properties, message): msg = yaml.load(message) #CHECK: The message should be a dictionary. self.assertTrue(isinstance(msg, dict), msg='message is not a dictionary') #CHECK: The dictionary should have a key 'name'. self.assertIn('name', msg.keys(), msg='No name provided in message.') if isinstance(msg['name'], str): #CHECK: The value of 'name' should not be an empty string. self.assertTrue(len(msg['name']) > 0, msg='empty name provided.') else: #CHECK: The value of 'name' should be a string self.assertEqual(True, False, msg='name is not a string') #CHECK: The dictionary should have a key 'version'. self.assertIn('version', msg.keys(), msg='No version provided in message.') if isinstance(msg['version'], str): #CHECK: The value of 'version' should not be an empty string. self.assertTrue(len(msg['version']) > 0, msg='empty version provided.') else: #CHECK: The value of 'version' should be a string self.assertEqual(True, False, msg='version is not a string') #CHECK: The dictionary should have a key 'description' self.assertIn('description', msg.keys(), msg='No description provided in message.') if isinstance(msg['description'], str): #CHECK: The value of 'description' should not be an empty string. self.assertTrue(len(msg['description']) > 0, msg='empty description provided.') else: #CHECK: The value of 'description' should be a string self.assertEqual(True, False, msg='description is not a string') # stop waiting self.eventFinished1() #STEP1: Listen to the platform.management.plugin.register topic self.manoconn.subscribe(on_register_receive, 'platform.management.plugin.register') #STEP2: Start the Placement Executive self.plex_proc.start() #STEP3b: When not receiving the message, the test failed self.waitForEvent1(timeout=5, msg="message not received.") def test_2_PLEX_request_response(self): def on_request_send(ch, method, properties, message): if properties.app_id == "son-plugin.PlacementExecutive": msg = yaml.load(message) self.assertTrue(isinstance(msg, dict), msg='message is not a dictionary') self.assertIn('uuid', msg.keys(), msg='No uuid provided in message.') if isinstance(msg['uuid'], str): self.assertTrue(msg['uuid'] == '1234', msg='empty uuid provided.') self.assertNotIn('place', msg.keys(), msg='wrong message.') res_payload = yaml.dump({'uuid': '1234', 'place': '2'}) self.eventFinished1() return res_payload def on_response_send(ch, method, properties, message): if properties.app_id == "son-plugin.PlacementExecutive": msg = yaml.load(message) self.assertTrue(isinstance(msg, dict), msg='message is not a dictionary') self.assertIn('uuid', msg.keys(), msg='No uuid provided in message.') if isinstance(msg['uuid'], str): self.assertTrue(msg['uuid'] == '1234', msg='empty uuid provided.') self.assertIn('place', msg.keys(), msg='No place provided in message.') if isinstance(msg['place'], str): self.assertTrue(msg['place'] == '2', msg='empty uuid provided.') self.eventFinished2() self.plex_proc.start() time.sleep(2) self.manoconn.subscribe(on_response_send, 'placement.executive.request') self.sm_connection.register_async_endpoint(on_request_send, 'placement.ssm.1234') req_payload = yaml.dump({'uuid': '1234'}) self.manoconn.publish("placement.executive.request", message=req_payload) self.waitForEvent1(timeout=5, msg="response message not received.") self.waitForEvent2(timeout=5, msg="request message not received.")
class TestPluginManagerBase(unittest.TestCase): """ Commen functionalities used my many test cases """ pm_proc = None @classmethod def setUpClass(cls): # start the plugin manger in another process so that we can connect to it using its broker interface cls.pm_proc = Process(target=SonPluginManager) cls.pm_proc.daemon = True cls.pm_proc.start() time.sleep(1) # give the plugin manager some time to start @classmethod def tearDownClass(cls): if cls.pm_proc is not None: cls.pm_proc.terminate() del cls.pm_proc def setUp(self): # initialize messaging subsystem self.m = ManoBrokerRequestResponseConnection("pm-client" + self.id()) self.wait_for_reply = threading.Event() self.plugin_uuid = None def tearDown(self): self.m.stop_connection() self.m.stop_threads() del self.m def waitForMessage(self, timeout=5): self.wait_for_reply.clear() if not self.wait_for_reply.wait(timeout): raise Exception("Timeout in wait for reply message.") def messageReceived(self): self.wait_for_reply.set() def register(self): """ Helper: We need this in many tests. :return: """ def on_register_reply(ch, method, properties, message): msg = json.loads(str(message)) assert (msg.get("status") == "OK") assert (len(msg.get("uuid")) > 0) assert (msg.get("error") is None) # set internal state variables self.plugin_uuid = msg.get("uuid") # stop waiting self.messageReceived() # create register request message msg = dict(name="test-plugin", version="v0.01", description="description") # do the registration call self.m.call_async(on_register_reply, "platform.management.plugin.register", json.dumps(msg)) # make our test synchronous: wait self.waitForMessage() def deregister(self): """ Helper: We need this in many tests. :return: """ assert (self.plugin_uuid is not None) def on_deregister_reply(ch, method, properties, message): msg = json.loads(str(message)) assert (msg.get("status") == "OK") # stop waiting self.messageReceived() # create register request message msg = dict(uuid=self.plugin_uuid) # do the registration call self.m.call_async(on_deregister_reply, "platform.management.plugin.deregister", json.dumps(msg)) # make our test synchronous: wait self.waitForMessage()