def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("onos-service", "onos.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from sync_onos_service import SyncONOSService, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONOSService self.onos = Mock(spec=[ 'id', 'name', "rest_hostname", "rest_port", "rest_username", "rest_password", "class_names" ]) self.onos.id = 1 self.onos.name = "onos" self.onos.rest_hostname = "onos-url" self.onos.rest_port = "8181" self.onos.rest_username = "******" self.onos.rest_password = "******" self.onos.class_names = "ONOSService" self.service = Mock() self.service.id = 1 self.service.serviceattribute_dict = {} self.service.leaf_model = self.onos self.onos_service_attribute = Mock( spec=['id', 'service', 'name', 'value']) self.onos_service_attribute.service = self.service self.onos_service_attribute.name = "/onos/v1/network/configuration/apps/org.opencord.olt" self.onos_service_attribute.value = { "kafka": { "bootstrapServers": "cord-kafka-kafka.default.svc.cluster.local:9092" } }
def setUp(self): self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("ntt-workflow-driver", "ntt-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from model_policy_ntt_workflow_driver_serviceinstance import NttWorkflowDriverServiceInstancePolicy, NttHelpers self.NttHelpers = NttHelpers # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to # creation of tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() self.policy = NttWorkflowDriverServiceInstancePolicy(model_accessor=model_accessor) self.si = NttWorkflowDriverServiceInstance() self.si.owner = NttWorkflowDriverService() self.si.serial_number = "BRCM1234"
def setUp(self): global ComputeNodePolicy, MockObjectList self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from model_policy_compute_nodes import ComputeNodePolicy, model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to # creation of tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() self.policy = ComputeNodePolicy self.model = Mock()
def setUp(self): global VOLTServiceInstancePolicy, MockObjectList self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from model_policy_voltserviceinstance import VOLTServiceInstancePolicy # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a ServiceInstance may lead to creation of # tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() self.policy = VOLTServiceInstancePolicy(model_accessor=self.model_accessor) self.si = Mock()
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config( test_path, [("ntt-workflow-driver", "ntt-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from onu_event import ONUEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.log = Mock() self.event_step = ONUEventStep(model_accessor=self.model_accessor, log=self.log) self.event = Mock() self.event_dict = { 'status': 'activated', 'serialNumber': 'BRCM1234', 'deviceId': 'of:109299321', 'portNumber': '16' } self.event.value = json.dumps(self.event_dict) self.pppoe = NttWorkflowDriverService(name="ntt-workflow-driver") self.pon_port = PONPort() self.pon_port.port_no = 1234 self.onu = ONUDevice() self.onu.pon_port = self.pon_port self.onu.serial_number = "BRCM1234" self.onu.mac_address = "0a0a0a" self.technologyProfile = TechnologyProfile() self.technologyProfile.profile_id = 64 self.technologyProfile.profile_value = '{"profile_type": "EPON","epon_attribute": {"package_type": "A"}}'
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("vrouter", "vrouter.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from sync_routes import SyncRoutes, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncRoutes self.sync_step.log = Mock() # mock onos-fabric onos_fabric = Mock() onos_fabric.name = "onos-fabric" onos_fabric.rest_hostname = "onos-fabric" onos_fabric.rest_port = "8181" onos_fabric.rest_username = "******" onos_fabric.rest_password = "******" onos_fabric_base = Mock() onos_fabric_base.leaf_model = onos_fabric self.fabric = Mock() self.fabric.name = "fabric" self.fabric.provider_services = [onos_fabric_base] self.vrouter = Mock() self.vrouter.name = "vrouter" self.vrouter.provider_services = [self.fabric] # create a mock VRouterStaticRoute instance self.o = Mock() self.o.id = 1 self.o.vrouter.owner = self.vrouter self.o.tologdict.return_value = {}
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("vrouter", "vrouter.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from sync_routes import SyncRoutes, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncRoutes self.sync_step.log = Mock() # mock onos-fabric onos_fabric = Mock() onos_fabric.name = "onos-fabric" onos_fabric.rest_hostname = "onos-fabric" onos_fabric.rest_port = "8181" onos_fabric.rest_username = "******" onos_fabric.rest_password = "******" onos_fabric_base = Mock() onos_fabric_base.leaf_model = onos_fabric self.fabric = Mock() self.fabric.name = "fabric" self.fabric.provider_services = [onos_fabric_base] self.vrouter = Mock() self.vrouter.name = "vrouter" self.vrouter.provider_services = [self.fabric] # create a mock VRouterStaticRoute instance self.o = Mock() self.o.id = 1 self.o.vrouter.owner = self.vrouter self.o.tologdict.return_value = {}
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from sync_fabric_switch import SyncFabricSwitch # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncFabricSwitch self.sync_step.log = Mock() # mock onos-fabric onos_fabric = Mock() onos_fabric.name = "onos-fabric" onos_fabric.rest_hostname = "onos-fabric" onos_fabric.rest_port = "8181" onos_fabric.rest_username = "******" onos_fabric.rest_password = "******" onos_fabric_base = Mock() onos_fabric_base.leaf_model = onos_fabric self.fabric = Mock() self.fabric.name = "fabric" self.fabric.provider_services = [onos_fabric_base] # create a mock Switch instance self.o = Mock() self.o.name = "MockSwitch" self.o.ofId = "of:1234"
def setup_sync_unit_test(test_path, globals_dict, models, config_fn="test_config.yaml"): """ Perform the common steps associated with setting up a synchronizer unit test. 1) Import xosconfig.Config and set it up to test_config.yaml in the current dir 2) Build the mock modelaccessor and import it 3) Import all model accessor classes into global space Arguments: test_path - path to the test case that is being run globals_dict - a dictionary to add global models to models - a list of pairs (service_name, xproto_name) config_fn - filename of config file) Returns: Dictionary containing the following: sys_path_save: the original sys.path model_accessor: model accessor class Config: the Config object xos_dir: xos directory services_dir: services directory """ sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, config_fn) Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, models) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous testp from xossynchronizer.modelaccessor import model_accessor # modelaccessor.py will have ensure mock_modelaccessor is in sys.path from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals_dict[k] = v return { "sys_path_save": sys_path_save, "model_accessor": model_accessor, "Config": Config, "MockObjectList": MockObjectList }
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from multistructlog import create_logger log = create_logger(Config().get('logging')) # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("dt-workflow-driver", "dt-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from pppoe_event import SubscriberPppoeEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.log = log self.event_step = SubscriberPppoeEventStep(model_accessor=self.model_accessor, log=self.log) self.event = Mock() self.volt = Mock() self.volt.name = "vOLT" self.volt.leaf_model = Mock() # self.subscriber = RCORDSubscriber() # self.subscriber.onu_device = "BRCM1234" # self.subscriber.save = Mock() self.mac_address = "00:AA:00:00:00:01" self.ip_address = "192.168.3.5" self.pppoe_session_id = "12" self.si = DtWorkflowDriverServiceInstance() self.si.serial_number = "BRCM1234" self.si.save = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_fabric_crossconnect_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("fabric-crossconnect", "fabric-crossconnect.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from sync_fabric_crossconnect_service_instance import SyncFabricCrossconnectServiceInstance, model_accessor, \ DeferredException from helpers import Helpers self.helpers = Helpers # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncFabricCrossconnectServiceInstance self.sync_step.log = Mock() # mock onos-fabric self.onos_fabric = Service(name="onos-fabric", rest_hostname="onos-fabric", rest_port="8181", rest_username="******", rest_password="******") self.service = FabricCrossconnectService( name="fcservice", provider_services=[self.onos_fabric])
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config( test_path, [("dt-workflow-driver", "dt-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from onu_event import ONUEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.log = Mock() self.event_step = ONUEventStep(model_accessor=self.model_accessor, log=self.log) self.event = Mock() self.event_dict = { 'status': 'activated', 'serialNumber': 'BRCM1234', 'deviceId': 'of:109299321', 'portNumber': '16' } self.event.value = json.dumps(self.event_dict) self.pppoe = DtWorkflowDriverService(name="dt-workflow-driver")
def setup_sync_unit_test(test_path, globals_dict, models, config_fn="test_config.yaml"): """ Perform the common steps associated with setting up a synchronizer unit test. 1) Import xosconfig.Config and set it up to test_config.yaml in the current dir 2) Build the mock modelaccessor and import it 3) Import all model accessor classes into global space Arguments: test_path - path to the test case that is being run globals_dict - a dictionary to add global models to models - a list of pairs (service_name, xproto_name) config_fn - filename of config file) Returns: Dictionary containing the following: sys_path_save: the original sys.path model_accessor: model accessor class Config: the Config object xos_dir: xos directory services_dir: services directory """ sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, config_fn) Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, models) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous testp from xossynchronizer.modelaccessor import model_accessor # modelaccessor.py will have ensure mock_modelaccessor is in sys.path from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals_dict[k] = v return {"sys_path_save": sys_path_save, "model_accessor": model_accessor, "Config": Config, "MockObjectList": MockObjectList}
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from sync_fabric_port import SyncFabricPort # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncFabricPort self.sync_step.log = Mock() # mock onos-fabric onos_fabric = Mock() onos_fabric.name = "onos-fabric" onos_fabric.rest_hostname = "onos-fabric" onos_fabric.rest_port = "8181" onos_fabric.rest_username = "******" onos_fabric.rest_password = "******" onos_fabric_base = Mock() onos_fabric_base.leaf_model = onos_fabric self.fabric = Mock() self.fabric.name = "fabric" self.fabric.provider_services = [onos_fabric_base]
def setUp(self): self.mock_etcd = Mock(name="etcd-client") etcd = Mock(name="etcd-mocked-lib") etcd.client.return_value = self.mock_etcd modules = { 'etcd3': etcd } self.module_patcher = patch.dict('sys.modules', modules) self.module_patcher.start() self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from xossynchronizer.modelaccessor import model_accessor from sync_tech_profile import SyncTechnologyProfile # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncTechnologyProfile self.o = Mock() self.o.technology = "test_technology" self.o.profile_id = 64 self.o.profile_value = '{"test":"profile"}' self.o.tologdict.return_value = {'name': "mock-tp"}
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from multistructlog import create_logger log = create_logger(Config().get('logging')) # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config( test_path, [("att-workflow-driver", "att-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from auth_event import SubscriberAuthEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.log = log self.event_step = SubscriberAuthEventStep( model_accessor=self.model_accessor, log=self.log) self.event = Mock() self.att_si = AttWorkflowDriverServiceInstance() self.att_si.serial_number = "BRCM1234" self.att_si.save = Mock()
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"), ]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from xossynchronizer.steps.syncstep import DeferredException from sync_onu_device import SyncONUDevice, model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONUDevice volt_service = Mock() volt_service.voltha_url = "voltha_url" volt_service.voltha_port = 1234 volt_service.voltha_user = "******" volt_service.voltha_pass = "******" self.o = Mock() self.o.device_id = "test_id" self.o.pon_port.olt_device.volt_service = volt_service
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from xossynchronizer.modelaccessor import model_accessor from sync_onu_device import SyncONUDevice # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONUDevice volt_service = Mock() volt_service.voltha_url = MOCK_VOLTHA_SERVER_ADDRESS volt_service.voltha_port = MOCK_VOLTHA_SERVER_PORT self.o = Mock() self.o.device_id = "test_id" self.o.pon_port.olt_device.volt_service = volt_service clear_voltha_client_cache() self.server = grpc.server(ThreadPoolExecutor(max_workers=5)) self.voltha_mock, _, _ = VolthaServerMock.start_voltha_server( self.server)
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("onos-service", "onos.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.attr = ServiceInstanceAttribute( name="foo", value="bar" ) self.mockAllAttr = Mock() self.mockAllAttr.all.return_value = [self.attr] self.app1 = ONOSApp(name="myapp1", owner=self.onos, backend_code=1, backend_status="succeeded", service_instance_attributes=self.mockAllAttr) self.app2 = ONOSApp(name="myapp2", owner=self.onos, backend_code=1, backend_status="succeeded", service_instance_attributes=self.mockAllAttr) self.onos.service_instances = MockObjectList([self.app1, self.app2]) self.log = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from xossynchronizer.steps.syncstep import DeferredException from sync_volt_service_instance import SyncVOLTServiceInstance, model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncVOLTServiceInstance # create a mock ONOS Service onos = Mock() onos.name = "ONOS" onos.leaf_model.rest_hostname = "onos_voltha_url" onos.leaf_model.rest_port = 4321 onos.leaf_model.rest_username = "******" onos.leaf_model.rest_password = "******" volt_service = Mock() volt_service.provider_services = [onos] uni_port = Mock() uni_port.port_no = "uni_port_id" onu_device = Mock() onu_device.name = "BRCM1234" onu_device.pon_port.olt_device.dp_id = None onu_device.pon_port.olt_device.name = "Test OLT Device" onu_device.uni_ports.first.return_value = uni_port # create a mock service instance o = Mock() o.policy_code = 1 o.id = 1 o.owner_id = "volt_service" o.onu_device = onu_device o.tologdict.return_value = {} self.o = o self.onu_device = onu_device self.volt_service = volt_service
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"), ]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from pull_onus import ONUDevicePullStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = ONUDevicePullStep # mock volt service self.volt_service = Mock() self.volt_service.id = "volt_service_id" self.volt_service.voltha_url = "voltha_url" self.volt_service.voltha_user = "******" self.volt_service.voltha_pass = "******" self.volt_service.voltha_port = 1234 # mock OLTDevice self.olt = Mock() self.olt.id = 1 # second mock OLTDevice self.olt2 = Mock() self.olt2.id = 2 # mock pon port self.pon_port = Mock() self.pon_port.id = 1 # mock pon port self.pon_port2 = Mock() self.pon_port2.id = 2 # mock voltha responses self.devices = { "items": [{ "id": "0001130158f01b2d", "type": "broadcom_onu", "vendor": "Broadcom", "serial_number": "BRCM22222222", "vendor_id": "BRCM", "adapter": "broadcom_onu", "vlan": 0, "admin_state": "ENABLED", "oper_status": "ACTIVE", "connect_status": "REACHABLE", "reason": "starting-omci", "parent_id": "00010fc93996afea", "parent_port_no": 1 }] } self.two_devices = { "items": [{ "id": "0001130158f01b2d", "type": "broadcom_onu", "vendor": "Broadcom", "serial_number": "BRCM22222222", "vendor_id": "BRCM", "adapter": "broadcom_onu", "vlan": 0, "admin_state": "ENABLED", "oper_status": "ACTIVE", "connect_status": "REACHABLE", "reason": "starting-omci", "parent_id": "00010fc93996afea", "parent_port_no": 1 }, { "id": "0001130158f01b2e", "type": "broadcom_onu", "vendor": "Broadcom", "serial_number": "BRCM22222223", "vendor_id": "BRCM", "adapter": "broadcom_onu", "vlan": 0, "admin_state": "ENABLED", "oper_status": "ACTIVE", "connect_status": "REACHABLE", "reason": "omci-admin-lock", "parent_id": "00010fc93996afeb", "parent_port_no": 1 }], } # TODO add ports self.ports = {"items": []}
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("onos-service", "onos.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from sync_onos_app import SyncONOSApp, DeferredException, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONOSApp onos = ONOSService() onos.rest_hostname = "onos-url" onos.rest_port = "8181" onos.rest_username = "******" onos.rest_password = "******" self.onos_app = Mock(spec=[ 'id', 'name', 'app_id', 'dependencies', 'owner', 'url', 'backend_code', 'version', 'tologdict' ]) self.onos_app.id = 1 self.onos_app.name = "vrouter" self.onos_app.app_id = "org.onosproject.vrouter" self.onos_app.dependencies = "" self.onos_app.owner.leaf_model = onos self.onos_app.url = None self.onos_app.class_names = "ONOSApp" self.onos_app.tologdict.return_value = "" self.si = Mock() self.si.id = 1 self.si.leaf_model = self.onos_app self.vrouter_app_response = { "name": "org.onosproject.vrouter", "version": "1.13.1", } self.onos_app_attribute = Mock( spec=['id', 'service_instance', 'name', 'value']) self.onos_app_attribute.id = 1 self.onos_app_attribute.service_instance = self.si self.onos_app_attribute.name = "/onos/v1/network/configuration/apps/org.opencord.olt" self.onos_app_attribute.value = { "kafka": { "bootstrapServers": "cord-kafka-kafka.default.svc.cluster.local:9092" } }
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module # Mock the kafka producer self.mockxoskafka = MagicMock() modules = { 'xoskafka': self.mockxoskafka, 'xoskafka.XOSKafkaProducer': self.mockxoskafka.XOSKafkaProducer, } self.module_patcher = patch.dict('sys.modules', modules) self.module_patcher.start() from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList # necessary to reset XOSKafkaProducer's call_count import onos_event reload(onos_event) from onos_event import OnosPortEventStep, XOSKafkaProducer self.XOSKafkaProducer = XOSKafkaProducer # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = OnosPortEventStep self.fabric_service = FabricService(name="fabric", id=1112, backend_code=1, backend_status="succeeded") self.switch = Switch(name="switch1", ofId="of:0000000000000001", backend_code=1, backend_status="succeeded") self.port1 = SwitchPort(name="switch1port1", switch=self.switch, switch_id=self.switch.id, portId="1", oper_status=None, backend_code=1, backend_status="succeeded") self.port2 = SwitchPort(name="switch1port2", kind="access", switch=self.switch, switch_id=self.switch.id, portId="2", oper_status=None, backend_code=1, backend_status="succeeded") self.switch.ports = MockObjectList([self.port1, self.port2]) self.log = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from pull_onus import ONUDevicePullStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = ONUDevicePullStep # mock volt service self.volt_service = Mock() self.volt_service.id = "volt_service_id" self.volt_service.voltha_url = MOCK_VOLTHA_SERVER_ADDRESS self.volt_service.voltha_port = MOCK_VOLTHA_SERVER_PORT # mock OLTDevice self.olt = Mock() self.olt.id = 1 # second mock OLTDevice self.olt2 = Mock() self.olt2.id = 2 # mock pon port self.pon_port = Mock() self.pon_port.id = 1 # mock pon port self.pon_port2 = Mock() self.pon_port2.id = 2 # Mock gRPC server clear_voltha_client_cache() self.server = grpc.server(ThreadPoolExecutor(max_workers=5)) self.voltha_mock, _, _ = VolthaServerMock.start_voltha_server( self.server) # Server is actually started on single tests because different tests build different mocks # mock voltha responses self.devices = { "items": [{ "id": "0001130158f01b2d", "type": "broadcom_onu", "vendor": "Broadcom", "serial_number": "BRCM22222222", "vendor_id": "BRCM", "adapter": "broadcom_onu", "vlan": 0, "admin_state": "ENABLED", "oper_status": "ACTIVE", "connect_status": "REACHABLE", "reason": "starting-omci", "parent_id": "00010fc93996afea", "parent_port_no": 1 }] } self.ports_dict = {"0001130158f01b2d": {"items": []}} self.two_devices = { "items": [{ "id": "0001130158f01b2d", "type": "broadcom_onu", "vendor": "Broadcom", "serial_number": "BRCM22222222", "vendor_id": "BRCM", "adapter": "broadcom_onu", "vlan": 0, "admin_state": "ENABLED", "oper_status": "ACTIVE", "connect_status": "REACHABLE", "reason": "starting-omci", "parent_id": "00010fc93996afea", "parent_port_no": 1 }, { "id": "0001130158f01b2e", "type": "broadcom_onu", "vendor": "Broadcom", "serial_number": "BRCM22222223", "vendor_id": "BRCM", "adapter": "broadcom_onu", "vlan": 0, "admin_state": "ENABLED", "oper_status": "ACTIVE", "connect_status": "REACHABLE", "reason": "omci-admin-lock", "parent_id": "00010fc93996afeb", "parent_port_no": 1 }], } # TODO add ports self.two_ports_dict = { "0001130158f01b2d": { "items": [] }, "0001130158f01b2e": { "items": [] } }
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module # Mock the kafka producer self.mockxoskafka = MagicMock() modules = { 'xoskafka': self.mockxoskafka, 'xoskafka.XOSKafkaProducer': self.mockxoskafka.XOSKafkaProducer, } self.module_patcher = patch.dict('sys.modules', modules) self.module_patcher.start() from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload( mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList # necessary to reset XOSKafkaProducer's call_count import onos_event reload(onos_event) from onos_event import OnosPortEventStep, XOSKafkaProducer self.XOSKafkaProducer = XOSKafkaProducer # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = OnosPortEventStep self.fabric_service = FabricService(name="fabric", id=1112, backend_code=1, backend_status="succeeded") self.switch = Switch(name="switch1", ofId="of:0000000000000001", backend_code=1, backend_status="succeeded") self.port1 = SwitchPort(name="switch1port1", switch=self.switch, switch_id=self.switch.id, portId="1", oper_status=None, backend_code=1, backend_status="succeeded") self.port2 = SwitchPort(name="switch1port2", kind="access", switch=self.switch, switch_id=self.switch.id, portId="2", oper_status=None, backend_code=1, backend_status="succeeded") self.switch.ports = MockObjectList([self.port1, self.port2]) self.log = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"), ]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from sync_olt_device import SyncOLTDevice, DeferredException self.sync_step = SyncOLTDevice pon_port = Mock() pon_port.port_id = "00ff00" # Create a mock OLTDevice o = Mock() o.volt_service.voltha_url = "voltha_url" o.volt_service.voltha_port = 1234 o.volt_service.voltha_user = "******" o.volt_service.voltha_pass = "******" o.volt_service.onos_voltha_port = 4321 o.volt_service.onos_voltha_url = "onos" o.volt_service.onos_voltha_user = "******" o.volt_service.onos_voltha_pass = "******" o.device_type = "ponsim_olt" o.host = "172.17.0.1" o.port = "50060" o.uplink = "129" o.driver = "voltha" o.name = "Test Device" o.admin_state = "ENABLED" # feedback state o.device_id = None o.oper_status = None o.of_id = None o.id = 1 o.tologdict.return_value = {'name': "Mock VOLTServiceInstance"} o.save.return_value = "Saved" o.pon_ports.all.return_value = [pon_port] self.o = o self.voltha_devices_response = {"id": "123", "serial_number": "foobar"}
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", id=1111, rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.fabric_service = FabricService(name="fabric", id=1112, backend_code=1, backend_status="succeeded", provider_services=[self.onos]) self.switch = Switch(name="switch1", backend_code=1, backend_status="succeeded") self.port1 = SwitchPort(name="switch1port1", switch=self.switch, backend_code=1, backend_status="succeeded") self.port2 = SwitchPort(name="switch1port2", switch=self.switch, backend_code=1, backend_status="succeeded") self.switch.ports = MockObjectList([self.port1, self.port2]) self.log = Mock()
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from multistructlog import create_logger self.log = create_logger(Config().get('logging')) from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config( test_path, [("ntt-workflow-driver", "ntt-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from helpers import NttHelpers # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.helpers = NttHelpers self.model_accessor = model_accessor self._volt = VOLTService() self._volt.id = 1 self.volt = Service() self.volt.id = 1 self.volt.name = "vOLT" self.volt.leaf_model = self._volt self.pon_port = PONPort() self.pon_port.port_no = 1234 self.onu = ONUDevice() self.onu.pon_port = self.pon_port self.onu.serial_number = "BRCM1234" self.technologyProfile = TechnologyProfile() self.technologyProfile.profile_id = 64 self.technologyProfile.profile_value = '{"profile_type": "EPON","epon_attribute": {"package_type": "A"}}' self.ntt_si = NttWorkflowDriverServiceInstance( serial_number="BRCM1234", owner=self.volt, owner_id=self.volt.id, mac_address="0a0a0a", of_dpid="of:1234") self.whitelist_entry = NttWorkflowDriverWhiteListEntry( mac_address="0a0a0a", owner=self.volt, owner_id=self.volt.id, pon_port_from=1234, pon_port_to=1235, )
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"),]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from pull_olts import OLTDevicePullStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = OLTDevicePullStep # mock volt service self.volt_service = Mock() self.volt_service.id = "volt_service_id" self.volt_service.voltha_url = "voltha_url" self.volt_service.voltha_user = "******" self.volt_service.voltha_pass = "******" self.volt_service.voltha_port = 1234 # mock voltha responses self.devices = { "items": [ { "id": "test_id", "type": "simulated_olt", "host_and_port": "172.17.0.1:50060", "admin_state": "ENABLED", "oper_status": "ACTIVE", "serial_number": "serial_number", } ] } self.logical_devices = { "items": [ { "root_device_id": "test_id", "id": "of_id", "datapath_id": "55334486016" } ] } self.ports = { "items": [ { "label": "PON port", "port_no": 1, "type": "PON_OLT", "admin_state": "ENABLED", "oper_status": "ACTIVE" }, { "label": "NNI facing Ethernet port", "port_no": 2, "type": "ETHERNET_NNI", "admin_state": "ENABLED", "oper_status": "ACTIVE" } ] }
def setUp(self): global DeferredException self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", id=1111, rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.fcservice = VOLTService(name="myoltservice", id=1112, backend_code=1, backend_status="succeeded", provider_services=[self.onos]) self.fcsi1 = VOLTServiceInstance(name="myfcsi1", owner=self.fcservice, backend_code=1, backend_status="succeeded") self.fcsi2 = VOLTServiceInstance(name="myfcsi2", owner=self.fcservice, backend_code=1, backend_status="succeeded") self.fcservice.service_instances = MockObjectList( [self.fcsi1, self.fcsi2]) self.log = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", id=1111, rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.fabric_service = FabricService(name="fabric", id=1112, backend_code=1, backend_status="succeeded", provider_services=[self.onos]) self.switch = Switch(name="switch1", backend_code=1, backend_status="succeeded") self.port1 = SwitchPort(name="switch1port1", switch=self.switch, backend_code=1, backend_status="succeeded") self.port2 = SwitchPort(name="switch1port2", switch=self.switch, backend_code=1, backend_status="succeeded") self.switch.ports = MockObjectList([self.port1, self.port2]) self.log = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # Mock the kafka producer self.mockxoskafka = MagicMock() modules = { 'xoskafka': self.mockxoskafka, 'xoskafka.XOSKafkaProducer': self.mockxoskafka.XOSKafkaProducer, } self.module_patcher = patch.dict('sys.modules', modules) self.module_patcher.start() from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from mock_modelaccessor import MockObjectList from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor # necessary to reset XOSKafkaProducer's call_count import onos_event reload(onos_event) from onos_event import OnosPortEventStep, XOSKafkaProducer from onos_event import XOSKafkaProducer self.XOSKafkaProducer = XOSKafkaProducer # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = OnosPortEventStep self.volt_service = VOLTService(name="volt", id=1112, backend_code=1, backend_status="succeeded") self.oltdevice = OLTDevice(name="myolt", device_id="of:0000000000000001", switch_datapath_id="of:0000000000000001", switch_port="1") self.ponport = PONPort(olt_device = self.oltdevice) self.onudevice = ONUDevice(pon_port = self.ponport) self.subscriber = RCORDSubscriber(name="somesubscriber") self.voltsi = VOLTServiceInstance() # chain it all together self.oltdevice.pon_ports = MockObjectList([self.ponport]) self.ponport.onu_devices = MockObjectList([self.onudevice]) self.onudevice.volt_service_instances = MockObjectList([self.voltsi]) self.voltsi.westbound_service_instances = [self.subscriber] self.log = Mock()
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("onos-service", "onos.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from sync_onos_service import SyncONOSService, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONOSService self.onos = Mock(spec=[ 'id', 'name', "rest_hostname", "rest_port", "rest_username", "rest_password", "class_names" ]) self.onos.id = 1 self.onos.name = "onos" self.onos.rest_hostname = "onos-url" self.onos.rest_port = "8181" self.onos.rest_username = "******" self.onos.rest_password = "******" self.onos.class_names = "ONOSService" self.service = Mock() self.service.id = 1 self.service.serviceattribute_dict = {} self.service.leaf_model = self.onos self.onos_service_attribute = Mock(spec=[ 'id', 'service', 'name', 'value' ]) self.onos_service_attribute.service = self.service self.onos_service_attribute.name = "/onos/v1/network/configuration/apps/org.opencord.olt" self.onos_service_attribute.value = { "kafka": { "bootstrapServers": "cord-kafka-kafka.default.svc.cluster.local:9092" } }
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v from sync_olt_device import SyncOLTDevice, DeferredException self.sync_step = SyncOLTDevice pon_port = Mock() pon_port.port_id = "00ff00" # create a mock ONOS Service onos = Mock() onos.name = "ONOS" onos.leaf_model.rest_hostname = "onos" onos.leaf_model.rest_port = 4321 onos.leaf_model.rest_username = "******" onos.leaf_model.rest_password = "******" # Create a mock OLTDevice o = Mock() o.volt_service.voltha_url = "voltha_url" o.volt_service.voltha_port = 1234 o.volt_service.voltha_user = "******" o.volt_service.voltha_pass = "******" o.volt_service.provider_services = [onos] o.device_type = "ponsim_olt" o.host = "172.17.0.1" o.port = "50060" o.uplink = "129" o.driver = "voltha" o.name = "Test Device" o.admin_state = "ENABLED" # feedback state o.device_id = None o.oper_status = None o.serial_number = None o.of_id = None o.id = 1 o.tologdict.return_value = {'name': "Mock VOLTServiceInstance"} o.save_changed_fields.return_value = "Saved" o.pon_ports.all.return_value = [pon_port] self.o = o self.voltha_devices_response = {"id": "123", "serial_number": "foobar"} self.tp = TechnologyProfile(technology="xgspon", profile_id=64, profile_value="{}")
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from pull_olts import OLTDevicePullStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = OLTDevicePullStep # mock volt service self.volt_service = Mock() self.volt_service.id = "volt_service_id" self.volt_service.voltha_url = MOCK_VOLTHA_SERVER_ADDRESS self.volt_service.voltha_port = MOCK_VOLTHA_SERVER_PORT # Mock gRPC server for simulated OLTs clear_voltha_client_cache() self.server = grpc.server(ThreadPoolExecutor(max_workers=5)) self.voltha_mock, _, _, = VolthaServerMock.start_voltha_server( self.server) # VOLTHA server responses self.devices = { "items": [{ "id": "test_id", "type": "simulated_olt", "host_and_port": "172.17.0.1:50060", "admin_state": "ENABLED", "oper_status": "ACTIVE", "serial_number": "serial_number", }] } self.logical_devices = { "items": [{ "root_device_id": "test_id", "id": "of_id", "datapath_id": "55334486016" }] } self.ports_dict = { "test_id": { "items": [{ "label": "PON port", "port_no": 1, "type": "PON_OLT", "admin_state": "ENABLED", "oper_status": "ACTIVE" }, { "label": "NNI facing Ethernet port", "port_no": 2, "type": "ETHERNET_NNI", "admin_state": "ENABLED", "oper_status": "ACTIVE" }] } }