def test_customer_subscribe_service(mock_send_message, mock_send_message_json): customer = Customer(global_customer_id="test_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") mock_send_message_json.side_effect = (ResourceNotFound, SERVICE_SUBSCRIPTION) customer.subscribe_service("test_service")
def test_customer_subscribe_service(mock_send_message, mock_send_message_json): customer = Customer(global_customer_id="test_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") service = SdcService("test_service") service._unique_uuid = "1234" mock_send_message_json.side_effect = (ValueError, SERVICE_SUBSCRIPTION) customer.subscribe_service(service)
def test_customers_get_all(mock_send): """Test get_all Customer class method.""" mock_send.return_value = {} customers = list(Customer.get_all()) assert len(customers) == 0 mock_send.return_value = CUSTOMERS customers = list(Customer.get_all()) assert len(customers) == 1
def test_customers(mock_send): """Test get_customer function of A&AI.""" mock_send.return_value = SIMPLE_CUSTOMER assert len(list(Customer.get_all())) == 1 aai_customer_1 = next(Customer.get_all()) assert aai_customer_1.global_customer_id == "generic" assert aai_customer_1.subscriber_name == "generic" assert aai_customer_1.subscriber_type == "INFRA" assert aai_customer_1.resource_version == "1561218640404" mock_send.assert_called_with("GET", 'get customers', mock.ANY)
def execute(self): """Create cutomer. Use settings values: - GLOBAL_CUSTOMER_ID. """ super().execute() try: Customer.create(settings.GLOBAL_CUSTOMER_ID, settings.GLOBAL_CUSTOMER_ID, "INFRA") except APIError: self._logger.warn("Try to update the Customer failed.")
def test_create_customer(): requests.get(f"{Customer.base_url}/reset") customers = list(Customer.get_all()) assert len(customers) == 0 customer = Customer.create(global_customer_id="test_global_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") assert customer.global_customer_id == "test_global_customer_id" assert customer.subscriber_name == "test_subscriber_name" assert customer.subscriber_type == "test_subscriber_type" customers = list(Customer.get_all()) assert len(customers) == 1
def test_link_service_subscription_to_cloud_region_and_tenant(): requests.get(f"{Customer.base_url}/reset") customer = Customer.create(global_customer_id="test_global_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") customer.subscribe_service("service_type") service_subscription = customer.get_service_subscription_by_service_type( "service_type") assert len(list(service_subscription.relationships)) == 0 with pytest.raises(ParameterError): service_subscription.cloud_region with pytest.raises(ParameterError): service_subscription.tenant cloud_region = CloudRegion.create("test_owner", "test_cloud_region", orchestration_disabled=True, in_maint=False) cloud_region.add_tenant(tenant_id="test_tenant_name", tenant_name="test_tenant_name", tenant_context="test_tenant_context") tenant = cloud_region.get_tenant(tenant_id="test_tenant_name") service_subscription.link_to_cloud_region_and_tenant( cloud_region=cloud_region, tenant=tenant) assert service_subscription.cloud_region assert service_subscription.tenant
def test_customer_service_subscription_cloud_region(mock_cloud_region, mock_send_serv_sub, mock_send): """Test Customer's service subscription cloud region object.""" mock_send.return_value = CUSTOMERS customer = next(Customer.get_all()) mock_send.return_value = SERVICE_SUBSCRIPTION service_subscription = customer.get_service_subscription_by_service_type( "freeradius") mock_send_serv_sub.return_value = {} relationships = list(service_subscription.relationships) assert len(relationships) == 0 with pytest.raises(AttributeError): service_subscription.cloud_region with pytest.raises(AttributeError): service_subscription.tenant mock_cloud_region.return_value = CLOUD_REGION mock_send_serv_sub.return_value = SERVICE_SUBSCRIPTION_RELATIONSHIPS relationships = list(service_subscription.relationships) assert len(relationships) == 1 cloud_region = service_subscription.cloud_region assert cloud_region.cloud_owner == "OPNFV" assert cloud_region.cloud_region_id == "RegionOne" assert cloud_region.cloud_type == "openstack" mock_cloud_region.side_effect = ValueError with pytest.raises(AttributeError): service_subscription.tenant mock_cloud_region.side_effect = [CLOUD_REGION, TENANT] tenant = service_subscription.tenant assert tenant.tenant_id == "4bdc6f0f2539430f9428c852ba606808" assert tenant.name == "onap-dublin-daily-vnfs"
def test_customer_url(): """Test Customer's url property.""" customer = Customer("generic", "generic", "INFRA") assert customer.url == ( f"{customer.base_url}{customer.api_version}/business/customers/" f"customer/{customer.global_customer_id}?" f"resource-version={customer.resource_version}")
def execute(self): """Connect service subsription to cloud region and tenant. Use settings values: - GLOBAL_CUSTOMER_ID, - SERVICE_NAME, - CLOUD_REGION_CLOUD_OWNER, - CLOUD_REGION_ID. """ super().execute() customer: Customer = Customer.get_by_global_customer_id( settings.GLOBAL_CUSTOMER_ID) service_subscription: ServiceSubscription = customer.get_service_subscription_by_service_type( settings.SERVICE_NAME) cloud_region: CloudRegion = CloudRegion.get_by_id( cloud_owner=settings.CLOUD_REGION_CLOUD_OWNER, cloud_region_id=settings.CLOUD_REGION_ID, ) # retrieve tenant # for which we are sure that an availability zone has been created tenant: Tenant = cloud_region.get_tenant(settings.TENANT_ID) service_subscription.link_to_cloud_region_and_tenant( cloud_region=cloud_region, tenant=tenant)
def test_customer_get_service_subscription_by_service_type(mock_send): """Test Customer's get_service_subscription_by_service_type method.""" mock_send.return_value = CUSTOMERS customer = next(Customer.get_all()) mock_send.return_value = SERVICE_SUBSCRIPTION service_subscription = customer.get_service_subscription_by_service_type("freeradius") assert service_subscription.service_type == "freeradius"
def test_customer_service_tenant_relations(mock_send): """Test the retrieval of service/tenant relations in A&AI.""" mock_send.return_value = SIMPLE_CUSTOMER customer = next(Customer.get_all()) mock_send.return_value = SERVICE_SUBSCRIPTION res = list(customer.service_subscriptions) assert len(res) == 2 assert res[0].service_type == "freeradius"
def test_customer_create(mock_send_json, mock_send): """Test Customer's create method.""" mock_send_json.return_value = SIMPLE_CUSTOMER_2 customer = Customer.create("generic", "generic", "INFRA") assert customer.global_customer_id == "generic" assert customer.subscriber_name == "generic" assert customer.subscriber_type == "INFRA" assert customer.resource_version is not None
def test_customer_get_by_global_customer_id(mock_send): """Test Customer's get_by_global_customer_id method.""" mock_send.return_value = SIMPLE_CUSTOMER_2 customer = Customer.get_by_global_customer_id("generic") assert customer.global_customer_id == "generic" assert customer.subscriber_name == "generic" assert customer.subscriber_type == "INFRA" assert customer.resource_version is not None
def test_a_la_carte_vl_instantiation(): requests.get(f"{ServiceInstantiation.base_url}/reset") requests.get(f"{Customer.base_url}/reset") requests.post(f"{ServiceInstantiation.base_url}/set_aai_mock", json={"AAI_MOCK": settings.AAI_URL}) customer = Customer.create(global_customer_id="test_global_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") service = Service("test_service") service.unique_uuid = str(uuid4()) service.identifier = str(uuid4()) service.name = str(uuid4()) customer.subscribe_service("service_type") service_subscription = customer.get_service_subscription_by_service_type( "service_type") cloud_region = CloudRegion.create("test_owner", "test_cloud_region", orchestration_disabled=True, in_maint=False) cloud_region.add_tenant(tenant_id="test_tenant_name", tenant_name="test_tenant_name", tenant_context="test_tenant_context") tenant = cloud_region.get_tenant(tenant_id="test_tenant_name") service_subscription.link_to_cloud_region_and_tenant( cloud_region=cloud_region, tenant=tenant) owning_entity = "test_owning_entity" project = "test_project" # Service instantiation service._distributed = True assert len(list(service_subscription.service_instances)) == 0 service_instantiation_request = ServiceInstantiation.instantiate_ala_carte( service, cloud_region, tenant, customer, owning_entity, project, service_subscription) assert service_instantiation_request.status == ServiceInstantiation.StatusEnum.IN_PROGRESS service_instantiation_request.wait_for_finish() assert service_instantiation_request.status == ServiceInstantiation.StatusEnum.COMPLETED assert len(list(service_subscription.service_instances)) == 1 # Network instantiation service_instance = next(service_subscription.service_instances) assert len(list(service_instance.network_instances)) == 0 owning_entity = "test_owning_entity" project = "test_project" network = MagicMock() line_of_business = "test_line_of_business" platform = "test_platform" with pytest.raises(AttributeError): service_instance.network(network, line_of_business, platform) service_instance.orchestration_status = "Active" with patch.object(ServiceInstance, "sdc_service", return_value=service): network_instantiation_request = service_instance.add_network( network, line_of_business, platform) assert network_instantiation_request.status == VnfInstantiation.StatusEnum.IN_PROGRESS network_instantiation_request.wait_for_finish() assert network_instantiation_request.status == VnfInstantiation.StatusEnum.COMPLETED assert len(list(service_instance.network_instances)) == 1
def execute(self): """Create customer service subsription. Use settings values: - GLOBAL_CUSTOMER_ID, - SERVICE_NAME. """ super().execute() service = Service(name=settings.SERVICE_NAME) customer = Customer.get_by_global_customer_id( settings.GLOBAL_CUSTOMER_ID) customer.subscribe_service(service)
def test_subscribe_service(): requests.get(f"{Customer.base_url}/reset") customer = Customer.create(global_customer_id="test_global_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") assert len(list(customer.service_subscriptions)) == 0 customer.subscribe_service("service_type") assert len(list(customer.service_subscriptions)) == 1 assert customer.get_service_subscription_by_service_type("service_type")
def test_get_service_instance_by_filter_parameter(mock_send_message_json): """Test Service Subscription get_service_instance_by_filter_parameter method""" customer = Customer("generic", "generic", "INFRA") service_subscription = ServiceSubscription( customer=customer, service_type="test_service_type", resource_version="test_resource_version") mock_send_message_json.return_value = SERVICE_INSTANCES service_instance = service_subscription._get_service_instance_by_filter_parameter( filter_parameter_name="service-instance-id", filter_parameter_value="5410bf79-2aa3-450e-a324-ec5630dc18cf") assert service_instance.instance_name == "test" assert service_instance.instance_id == "5410bf79-2aa3-450e-a324-ec5630dc18cf"
def test_subscribe_service(): requests.get(f"{Customer.base_url}/reset") customer = Customer.create(global_customer_id="test_global_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") assert len(list(customer.service_subscriptions)) == 0 service = Service("test_service") service.unique_uuid = str(uuid4()) customer.subscribe_service(service) assert len(list(customer.service_subscriptions)) == 1 assert customer.get_service_subscription_by_service_type(service.name)
def execute(self): """Creation of k8s profile for resource bundle definition Use settings values: - GLOBAL_CUSTOMER_ID - K8S_PROFILE_K8S_VERSION - K8S_PROFILE_ARTIFACT_PATH. """ self._logger.info("Create the k8s profile if it doesn't exist") super().execute() customer: Customer = Customer.get_by_global_customer_id( settings.GLOBAL_CUSTOMER_ID) service_subscription: ServiceSubscription = customer.get_service_subscription_by_service_type( self.service_name) self._service_instance: ServiceInstance = service_subscription.get_service_instance_by_name( self.service_instance_name) for vnf_instance in self._service_instance.vnf_instances: # possible to have several modules for 1 VNF for vf_module in vnf_instance.vnf.vf_modules: # Define profile (rb_profile) for resource bundle definition # Retrieve resource bundle definition (rbdef) corresponding to vf module rbdef_name = vf_module.metadata["vfModuleModelInvariantUUID"] rbdef_version = vf_module.metadata["vfModuleModelUUID"] rbdef = Definition.get_definition_by_name_version( rbdef_name, rbdef_version) # Get k8s profile name from yaml service template vnf_parameters = self.get_vnf_parameters(vnf_instance.vnf.name) k8s_profile_name = "" k8s_profile_namespace = "" for param in vnf_parameters: if param.name == "k8s-rb-profile-name": k8s_profile_name = param.value if param.name == "k8s-rb-profile-namespace": k8s_profile_namespace = param.value if k8s_profile_name == "" or k8s_profile_namespace == "": self._logger.error("Missing rb profile information") raise onap_test_exceptions.ProfileInformationException ######## Check profile for Definition ################################### try: rbdef.get_profile_by_name(k8s_profile_name) except ResourceNotFound: ######## Create profile for Definition ################################### profile = rbdef.create_profile( k8s_profile_name, k8s_profile_namespace, settings.K8S_PROFILE_K8S_VERSION) ####### Upload artifact for created profile ############################## profile.upload_artifact( open(settings.K8S_PROFILE_ARTIFACT_PATH, 'rb').read())
def test_customer_service_subscription_service_instance(mock_send_serv_sub, mock_send): """Test Customer's service subscription service instances.""" mock_send.return_value = CUSTOMERS customer = next(Customer.get_all()) mock_send.return_value = SERVICE_SUBSCRIPTION service_subscription = customer.get_service_subscription_by_service_type("freeradius") mock_send_serv_sub.return_value = SERVICE_INSTANCES service_instances = list(service_subscription.service_instances) assert len(service_instances) == 1 service_instance = service_instances[0] assert service_instance.instance_name == "test" assert service_instance.instance_id == "5410bf79-2aa3-450e-a324-ec5630dc18cf" assert service_instance.service_subscription == service_subscription assert service_instance.url == (f"{service_subscription.url}/service-instances/" f"service-instance/{service_instance.instance_id}")
def execute(self): """Instantiate service. Use settings values: - SERVICE_NAME, - GLOBAL_CUSTOMER_ID, - CLOUD_REGION_CLOUD_OWNER, - CLOUD_REGION_ID, - TENANT_ID, - OWNING_ENTITY, - PROJECT, - SERVICE_INSTANCE_NAME. """ super().execute() service = Service(settings.SERVICE_NAME) customer: Customer = Customer.get_by_global_customer_id(settings.GLOBAL_CUSTOMER_ID) cloud_region: CloudRegion = CloudRegion.get_by_id( cloud_owner=settings.CLOUD_REGION_CLOUD_OWNER, cloud_region_id=settings.CLOUD_REGION_ID, ) tenant: Tenant = cloud_region.get_tenant(settings.TENANT_ID) try: owning_entity = AaiOwningEntity.get_by_owning_entity_name( settings.OWNING_ENTITY) except ResourceNotFound: self._logger.info("Owning entity not found, create it") owning_entity = AaiOwningEntity.create(settings.OWNING_ENTITY) vid_project = Project.create(settings.PROJECT) service_instantiation = ServiceInstantiation.instantiate_so_ala_carte( service, cloud_region, tenant, customer, owning_entity, vid_project, service_instance_name=settings.SERVICE_INSTANCE_NAME ) try: service_instantiation.wait_for_finish(settings.ORCHESTRATION_REQUEST_TIMEOUT) except TimeoutError: self._logger.error("Service instantiation %s timed out", self.service_instance_name) raise onap_test_exceptions.ServiceInstantiateException if service_instantiation.failed: self._logger.error("Service instantiation %s failed", self.service_instance_name) raise onap_test_exceptions.ServiceInstantiateException
def execute(self) -> None: """Instantiate Vf module. Use settings values: - GLOBAL_CUSTOMER_ID. Raises: Exception: Vf module instantiation failed """ super().execute() customer: Customer = Customer.get_by_global_customer_id( settings.GLOBAL_CUSTOMER_ID) service_subscription: ServiceSubscription = customer.get_service_subscription_by_service_type( self.service_name) self._service_instance: ServiceInstance = service_subscription.get_service_instance_by_name( self.service_instance_name) cloud_region: CloudRegion = CloudRegion.get_by_id( cloud_owner=settings.CLOUD_REGION_CLOUD_OWNER, cloud_region_id=settings.CLOUD_REGION_ID, ) tenant: Tenant = cloud_region.get_tenant(settings.TENANT_ID) for vnf_instance in self._service_instance.vnf_instances: # possible to have several moduels for 1 VNF for vf_module in vnf_instance.vnf.vf_modules: vf_module_instantiation = vnf_instance.add_vf_module( vf_module, cloud_region, tenant, self._service_instance_name, vnf_parameters=self.get_vnf_parameters( vnf_instance.vnf.name)) try: vf_module_instantiation.wait_for_finish( settings.ORCHESTRATION_REQUEST_TIMEOUT) if vf_module_instantiation.failed: self._logger.error("VfModule instantiation %s failed", vf_module.name) raise onap_test_exceptions.VfModuleInstantiateException except TimeoutError: self._logger.error("VfModule instantiation %s timed out", vf_module.name) raise onap_test_exceptions.VfModuleInstantiateException
def execute(self) -> None: """Instantiate Vl. Use settings values: - GLOBAL_CUSTOMER_ID. Raises: Exception: Vl instantiation failed """ super().execute() service: Service = Service(self.service_name) customer: Customer = Customer.get_by_global_customer_id( settings.GLOBAL_CUSTOMER_ID) service_subscription: ServiceSubscription = customer.get_service_subscription_by_service_type( self.service_name) service_instance: ServiceInstance = service_subscription.get_service_instance_by_name( self.service_instance_name) self._service_instance = service_instance line_of_business: LineOfBusiness = LineOfBusiness( settings.LINE_OF_BUSINESS) platform: Platform = Platform(settings.PLATFORM) for idx, network in enumerate(service.networks): #for network in self.yaml_template[self.service_name]["networks"]: net_instantiation = service_instance.add_network( network, line_of_business, platform, network_instance_name=f"{self.service_instance_name}_net_{idx}", subnets=self.get_subnets(network.name)) try: net_instantiation.wait_for_finish( settings.ORCHESTRATION_REQUEST_TIMEOUT) if net_instantiation.failed: self._logger.error("VL instantiation %s failed", net_instantiation.name) raise onap_test_exceptions.NetworkInstantiateException except TimeoutError: self._logger.error("VL instantiation %s timed out", net_instantiation.name) raise onap_test_exceptions.NetworkInstantiateException
def execute(self): """Instantiate vnf. Use settings values: - GLOBAL_CUSTOMER_ID, - LINE_OF_BUSINESS. Raises: Exception: VNF instantiation failed """ super().execute() service: Service = Service(self.service_name) customer: Customer = Customer.get_by_global_customer_id( settings.GLOBAL_CUSTOMER_ID) service_subscription: ServiceSubscription = customer.get_service_subscription_by_service_type( self.service_name) self._service_instance: ServiceInstance = service_subscription.get_service_instance_by_name( self.service_instance_name) line_of_business: LineOfBusiness = LineOfBusiness( settings.LINE_OF_BUSINESS) platform: Platform = Platform(settings.PLATFORM) cloud_region: CloudRegion = CloudRegion.get_by_id( cloud_owner=settings.CLOUD_REGION_CLOUD_OWNER, cloud_region_id=settings.CLOUD_REGION_ID, ) tenant: Tenant = cloud_region.get_tenant(settings.TENANT_ID) for idx, vnf in enumerate(service.vnfs): vnf_instantiation = self._service_instance.add_vnf( vnf, line_of_business, platform, cloud_region, tenant, f"{self.service_instance_name}_vnf_{idx}") try: vnf_instantiation.wait_for_finish( settings.ORCHESTRATION_REQUEST_TIMEOUT) if vnf_instantiation.failed: self._logger.error("VNF instantiation %s failed", vnf.name) raise onap_test_exceptions.VnfInstantiateException except TimeoutError: self._logger.error("VNF instantiation %s timed out", vnf.name) raise onap_test_exceptions.VnfInstantiateException
def resolve_hc_inputs(): logger.info("******** Check Customer *******") customer = None for found_customer in list(Customer.get_all()): logger.debug("Customer %s found", found_customer.subscriber_name) if found_customer.subscriber_name == Config.GLOBAL_CUSTOMER_ID: logger.info("Customer %s found", found_customer.subscriber_name) customer = found_customer break if customer is None: raise Exception("Customer %s wasn't found in ONAP" % Config.GLOBAL_CUSTOMER_ID) logger.info("******** Check Service Subscription *******") service_subscription = None for service_sub in customer.service_subscriptions: logger.debug("Service subscription %s is found", service_sub.service_type) if service_sub.service_type == Config.SERVICENAME: logger.info("Service %s subscribed", Config.SERVICENAME) service_subscription = service_sub break logger.info("******** Retrieve Service Metadata *******") service_instance = None for single_service in service_subscription.service_instances: if single_service.instance_name == Config.SERVICE_INSTANCE_NAME: service_instance = single_service break service_id = service_instance.instance_id vnfs = list(service_instance.vnf_instances) if len(vnfs) > 1: raise NotImplementedError( "Service %s is composed of more than one vnf!" % service_id) if not vnfs: raise Exception("Service %s doesn't contain any vnfs" % service_id) vnf_id = vnfs[0].vnf_id return service_id, vnf_id
logger = logging.getLogger("") logger.setLevel(logging.DEBUG) fh = logging.StreamHandler() fh_formatter = logging.Formatter( '%(asctime)s %(levelname)s %(lineno)d:%(filename)s(%(process)d) - %(message)s' ) fh.setFormatter(fh_formatter) logger.addHandler(fh) logger.info("*******************************") logger.info("**** SERVICE INSTANTIATION ****") logger.info("*******************************") logger.info("******** Create Customer *******") customer = None for found_customer in list(Customer.get_all()): logger.debug("Customer %s found", found_customer.subscriber_name) if found_customer.subscriber_name == Config.GLOBAL_CUSTOMER_ID: logger.info("Customer %s found", found_customer.subscriber_name) customer = found_customer break if not customer: customer = Customer.create(Config.GLOBAL_CUSTOMER_ID, Config.GLOBAL_CUSTOMER_ID, "INFRA") logger.info("******** Find Service in SDC *******") service = None services = Service.get_all() for found_service in services: logger.debug("Service %s is found, distribution %s", found_service.name, found_service.distribution_status)
from config import Config logger = logging.getLogger("") logger.setLevel(logging.DEBUG) fh = logging.StreamHandler() fh_formatter = logging.Formatter( '%(asctime)s %(levelname)s %(lineno)d:%(filename)s(%(process)d) - %(message)s' ) fh.setFormatter(fh_formatter) logger.addHandler(fh) logger.info("******** Get Customer *******") customer = None try: customer = Customer.get_by_global_customer_id(Config.GLOBAL_CUSTOMER_ID) except: logger.error("Customer not found") exit(1) logger.info("******** Check Service Subscription *******") service_subscription = None for service_sub in customer.service_subscriptions: if service_sub.service_type == Config.SERVICENAME: logger.info("Service %s subscribed", Config.SERVICENAME) service_subscription = service_sub break if not service_subscription: logger.error("Service Subscription not found") exit(1)
def test_customers_no_resources(mock_send): """Test get_customer function with no customer declared in A&AI.""" mock_send.return_value = CUSTOMERS_NO_RESOURCES assert len(list(Customer.get_all())) == 0 mock_send.assert_called_with("GET", 'get customers', mock.ANY)
def test_a_la_carte_instantiation(): requests.get(f"{ServiceInstantiation.base_url}/reset") requests.get(f"{Customer.base_url}/reset") requests.post(f"{ServiceInstantiation.base_url}/set_aai_mock", json={"AAI_MOCK": settings.AAI_URL}) customer = Customer.create(global_customer_id="test_global_customer_id", subscriber_name="test_subscriber_name", subscriber_type="test_subscriber_type") service = Service("test_service") service.unique_uuid = str(uuid4()) service.identifier = str(uuid4()) service.name = str(uuid4()) customer.subscribe_service(service) service_subscription = customer.get_service_subscription_by_service_type( service.name) cloud_region = CloudRegion.create("test_owner", "test_cloud_region", orchestration_disabled=True, in_maint=False) cloud_region.add_tenant(tenant_id="test_tenant_name", tenant_name="test_tenant_name", tenant_context="test_tenant_context") tenant = cloud_region.get_tenant(tenant_id="test_tenant_name") service_subscription.link_to_cloud_region_and_tenant( cloud_region=cloud_region, tenant=tenant) owning_entity = OwningEntity(name="test_owning_entity") project = Project(name="test_project") # Service instantiation service._distributed = True assert len(list(service_subscription.service_instances)) == 0 service_instantiation_request = ServiceInstantiation.instantiate_so_ala_carte( service, cloud_region, tenant, customer, owning_entity, project) assert service_instantiation_request.status == ServiceInstantiation.StatusEnum.IN_PROGRESS time.sleep( 2) # After 1 second mocked server changed request status to complete assert service_instantiation_request.status == ServiceInstantiation.StatusEnum.COMPLETED assert len(list(service_subscription.service_instances)) == 1 # Vnf instantiation service_instance = next(service_subscription.service_instances) assert len(list(service_instance.vnf_instances)) == 0 owning_entity = OwningEntity(name="test_owning_entity") project = Project(name="test_project") vnf = MagicMock() line_of_business = LineOfBusiness(name="test_line_of_business") platform = Platform(name="test_platform") with pytest.raises(AttributeError): service_instance.add_vnf(vnf, line_of_business, platform) service_instance.orchestration_status = "Active" with patch.object(ServiceSubscription, "sdc_service", return_value=service): vnf_instantiation_request = service_instance.add_vnf( vnf, line_of_business, platform) assert vnf_instantiation_request.status == VnfInstantiation.StatusEnum.IN_PROGRESS time.sleep( 2) # After 1 second mocked server changed request status to complete assert vnf_instantiation_request.status == VnfInstantiation.StatusEnum.COMPLETED assert len(list(service_instance.vnf_instances)) == 1 # VfModule instantiation vnf_instance = next(service_instance.vnf_instances) assert len(list(vnf_instance.vf_modules)) == 0 vnf.metadata = {"UUID": vnf_instance.model_version_id} vf_module = MagicMock() with patch.object(ServiceSubscription, "sdc_service", return_value=service) as service_mock: service_mock.vnfs = [vnf] vf_module_instantiation_request = vnf_instance.add_vf_module(vf_module) assert vf_module_instantiation_request.status == VfModuleInstantiation.StatusEnum.IN_PROGRESS time.sleep( 2) # After 1 second mocked server changed request status to complete assert vf_module_instantiation_request.status == VfModuleInstantiation.StatusEnum.COMPLETED assert len(list(vnf_instance.vf_modules)) == 1 # Cleanup vf_module_instance = next(vnf_instance.vf_modules) vf_module_deletion_request = vf_module_instance.delete() assert vf_module_deletion_request.status == VfModuleDeletionRequest.StatusEnum.IN_PROGRESS time.sleep( 2) # After 1 second mocked server changed request status to complete assert vf_module_deletion_request.status == VfModuleDeletionRequest.StatusEnum.COMPLETED assert len(list(vnf_instance.vf_modules)) == 0 vnf_deletion_request = vnf_instance.delete() assert vnf_deletion_request.status == VnfDeletionRequest.StatusEnum.IN_PROGRESS time.sleep( 2) # After 1 second mocked server changed request status to complete assert vnf_deletion_request.status == VnfDeletionRequest.StatusEnum.COMPLETED assert len(list(service_instance.vnf_instances)) == 0 with patch.object(ServiceSubscription, "sdc_service", return_value=service) as service_mock: service_deletion_request = service_instance.delete() assert service_deletion_request.status == ServiceDeletionRequest.StatusEnum.IN_PROGRESS time.sleep( 2) # After 1 second mocked server changed request status to complete assert service_deletion_request.status == ServiceDeletionRequest.StatusEnum.COMPLETED assert len(list(service_subscription.service_instances)) == 0