Merge "Doc VID version 3.2.3 (fix formatting)"
diff --git a/deliveries/src/main/docker/docker-files/Dockerfile b/deliveries/src/main/docker/docker-files/Dockerfile
index 3f9c1ad..9b46853 100755
--- a/deliveries/src/main/docker/docker-files/Dockerfile
+++ b/deliveries/src/main/docker/docker-files/Dockerfile
@@ -3,6 +3,8 @@
# add vim and uncomment alias to speedup troubleshooting purpose
RUN apk update && apk add openjdk8 vim net-tools
+RUN adduser --disabled-password onap onap
+RUN mkdir -p /opt/app
COPY conf.d/ /etc/onap/vid/conf.d/
# MariaDB variables
@@ -90,6 +92,7 @@
ADD maven/scripts/*.sh /tmp/vid/
ADD maven/artifacts/vid.war /tmp/vid/stage/
+RUN chown onap:onap /tmp/vid /usr/local/tomcat /etc/onap/vid /opt/app -R
RUN chmod +x /tmp/vid/localize.sh
-
-CMD ["/tmp/vid/localize.sh"]
\ No newline at end of file
+USER onap
+CMD ["/tmp/vid/localize.sh"]
diff --git a/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.js b/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.js
index 05a6cde..16ec01d 100755
--- a/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.js
+++ b/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.js
@@ -55,13 +55,11 @@
$scope.init();
$scope.fetchSubs(FIELD.PROMPT.FETCHING_SUBS);
$scope.fetchServices();
-
};
$scope.cancelCreateSI = function () {
window.location.href = COMPONENT.WELCOME_PATH;
-
};
$scope.getServiceTypes = function (globalCustomerId) {
diff --git a/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.test.js b/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.test.js
index 3e6bd2f..af3c218 100644
--- a/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.test.js
+++ b/vid-app-common/src/main/webapp/app/vid/scripts/controller/aaiSubscriberController.test.js
@@ -19,35 +19,1487 @@
*/
require('./aaiSubscriberController');
+require('../services/dataService');
+
const jestMock = require('jest-mock');
describe('TreeCtrl testing', () => {
- let $scope;
- beforeEach(
- angular.mock.module('app')
- );
+ var window;
- beforeEach(inject(function (_$controller_) {
- $scope = {};
- _$controller_('TreeCtrl', {
- $scope: $scope
+ let $scope;
+ beforeEach(
+ angular.mock.module('app')
+ );
+
+ beforeEach(inject(function (_$controller_) {
+ $scope = {};
+ _$controller_('TreeCtrl', {
+ $scope: $scope
+ });
+ }));
+
+ test('Verify expandAll calls broadcast with expand-all parameter', () => {
+ // given
+ const broadcast = jestMock.fn();
+ $scope.$broadcast = broadcast;
+ FIELD = {
+ ID: {
+ ANGULAR_UI_TREE_EXPANDALL: "angular-ui-tree:expand-all"
+ }
+ };
+ // when
+ $scope.expandAll();
+ // then
+ expect(broadcast).toHaveBeenCalledWith("angular-ui-tree:expand-all");
});
- }));
- test('Verify expandAll calls broadcast with expand-all parameter', () => {
- // given
- const broadcast = jestMock.fn();
- $scope.$broadcast = broadcast;
- FIELD = {
- ID: {
- ANGULAR_UI_TREE_EXPANDALL: "angular-ui-tree:expand-all"
- }
- };
- // when
- $scope.expandAll();
- // then
- expect(broadcast).toHaveBeenCalledWith("angular-ui-tree:expand-all");
- });
+ test('Verify collapseAll calls broadcast with collapse-all parameter', () => {
+ // given
+ const broadcast = jestMock.fn();
+ $scope.$broadcast = broadcast;
+ FIELD = {
+ ID: {
+ ANGULAR_UI_TREE_COLLAPSEALL: "angular-ui-tree:collapse-all"
+ }
+ };
+ // when
+ $scope.collapseAll();
+ // then
+ expect(broadcast).toHaveBeenCalledWith("angular-ui-tree:collapse-all");
+ });
+ test('Verify toggle calls toggle in given scope', () => {
+ // given
+ const testScope = {};
+ testScope.toggle = jestMock.fn();
+ // when
+ $scope.toggle(testScope);
+ // then
+ expect(testScope.toggle).toHaveBeenCalled();
+ });
+
+ test('Verify remove calls remove in given scope', () => {
+ // given
+ const testScope = {};
+ testScope.remove = jestMock.fn();
+ // when
+ $scope.remove(testScope);
+ // then
+ expect(testScope.remove).toHaveBeenCalled();
+ });
+
+ test('Verify moveLastToTheBeginning pops last element from data and puts it on the beginning', () => {
+ // given
+ $scope.data = [ 'a', 'b', 'c' ];
+ const expectedResult = [ 'c', 'a', 'b' ];
+
+ // when
+ $scope.moveLastToTheBeginning();
+ // then
+ expect($scope.data).toMatchObject(expectedResult);
+ });
+
+ test('Verify newSubItem pushes new item into given scope', () => {
+ // given
+ const testScope = {};
+ const testModel = {};
+
+ testModel.id = 2;
+ testModel.nodes = [];
+ testModel.title = 'testObject';
+
+ const expectedResult = {
+ id: 20,
+ title: 'testObject.1',
+ nodes: []
+ };
+
+ testScope.$modelValue = testModel;
+
+ // when
+ $scope.newSubItem(testScope);
+ // then
+ expect(testModel.nodes.length).toBe(1);
+ expect(testModel.nodes[0]).toMatchObject(expectedResult);
+ });
});
+describe('aaiSubscriberController testing', () => {
+
+ beforeEach(
+ angular.mock.module('app')
+ );
+
+ let $scope;
+ let $any;
+
+ let mockFIELD = {
+ PROMPT: {
+ SELECT_SERVICE: 'testService'
+ },
+ NAME: {
+ SERVICE_INSTANCE_ID: 'testID',
+ SERVICE_INSTANCE_NAME: 'testName'
+ },
+ ID: {
+ INVENTORY_RESPONSE_ITEMS: 0,
+ INVENTORY_RESPONSE_ITEM: 0
+ },
+ STYLE: {
+ MSO_CTRL_BTN: 'testButtonStyle',
+ },
+ STATUS: {
+ DONE: 'done',
+ },
+ ERROR: {
+ AAI: 'testAAIError',
+ FETCHING_SERVICE_TYPES: 'testServiceType',
+ SELECT: 'testAlertError',
+ },
+
+ };
+
+ let mockCOMPONENT = {
+ SHOW_COMPONENT_DETAILS: 'testComponentDetails',
+ VNF: 'testComponentVNF',
+ WELCOME_PATH: 'http://test/welcome/',
+ CREATE_INSTANCE_PATH: 'testInstancePath',
+ FEATURE_FLAGS:{},
+ };
+
+ let mockAaiService = {
+ getSubscriptionServiceTypeList(customerId,successFunction,failFunction){},
+ getServiceModelsByServiceType(queryId,customerId,serviceType,successFunction,failFunction){},
+ searchServiceInstances(query){},
+ };
+
+ let mockAsdcService = {
+ isMacro(item){},
+ shouldTakeTheAsyncInstantiationFlow(serviceModel){},
+ };
+
+ let mockPropertyService = {
+ retrieveMsoMaxPollingIntervalMsec(){return 1000},
+ setMsoMaxPollingIntervalMsec(msecs){},
+ retrieveMsoMaxPolls(){return 1000},
+ setMsoMaxPolls(polls){},
+ };
+
+ let mockUtilityService = {
+ };
+
+ let mockVidService = {
+ setModel(model){},
+ };
+
+ let dataService;
+
+ let mockLocation = {
+ path(path){},
+ };
+
+ let mockHttp = {
+ get(){},
+ };
+
+ let mockOwningEntityService = {
+ getOwningEntityProperties(callBack){}
+ };
+
+ let mockQ = {
+
+ };
+
+ $ = (selector) => {return mockSelector};
+ let mockSelector = {
+ addClass(){return this},
+ removeClass(){return this},
+ attr(){},
+ };
+
+ let mock_ = {
+ reduce(service,iterateeFunction,accumulatorFunction){},
+ forEach(services,iteratedFunction){},
+ includes(array, status){
+ return array.includes(status);
+ },
+ };
+
+ let mockedLog = {};
+
+ let mockFeatureFlags = {};
+
+ let mockVIDCONFIGURATION = {};
+
+ let mockRoute = {};
+
+ let mockUibModal = {};
+
+ let timeout;
+
+ beforeEach(inject(function (_$controller_,DataService,$timeout) {
+ $scope = {
+ $on(request,toDoFunction){}
+ };
+ $any = {};
+ dataService = DataService;
+ timeout = $timeout;
+ _$controller_('aaiSubscriberController', {
+ $scope: $scope,
+ COMPONENT: mockCOMPONENT,
+ FIELD: mockFIELD,
+ PARAMETER: $any,
+ DataService: DataService,
+ PropertyService: mockPropertyService,
+ $http: mockHttp,
+ $timeout: timeout,
+ $location: mockLocation,
+ $log: mockedLog,
+ $route: mockRoute,
+ $uibModal: mockUibModal,
+ VIDCONFIGURATION: mockVIDCONFIGURATION,
+ UtilityService: mockUtilityService,
+ vidService: mockVidService,
+ AaiService: mockAaiService,
+ MsoService: $any,
+ OwningEntityService: mockOwningEntityService,
+ AsdcService: mockAsdcService,
+ featureFlags: mockFeatureFlags,
+ $q: mockQ,
+ _: mock_
+ });
+ }));
+
+ test('Verify showVnfDetails calls proper broadcast methots with proper parameters', () => {
+ // given
+ const broadcast = jestMock.fn();
+ $scope.$broadcast = broadcast;
+
+ aaiResult = [[['test']]];
+
+ // when
+ $scope.showVnfDetails('testVNF');
+
+ // then
+ expect(broadcast).toHaveBeenCalledWith(mockCOMPONENT.SHOW_COMPONENT_DETAILS, { componentId: mockCOMPONENT.VNF,callbackFunction: expect.any(Function) } );
+ });
+
+ test('Verify getSubs will call fetchSubs and fetchServices and gets gets customer list from AaiService on success', () => {
+ // given
+ mockAaiService.getSubList = (successFunction,failFunction) => {
+ successFunction(['testCustomer1', 'testCustomer2']);
+ };
+ mockAaiService.getServices2 = (successFunction,failFunction) => {
+ successFunction('testListId');
+ };
+
+ // when
+ $scope.getSubs();
+
+ // then
+ expect( $scope.customerList ).toContain('testCustomer1','testCustomer2');
+ expect( dataService.getServiceIdList() ).toEqual('testListId');
+ });
+
+ test('Verify getSubs will call fetchSubs and fetchServices and return error message from AaiService on fail', () => {
+ // given
+ mockAaiService.getSubList = (successFunction,failFunction) => {
+ failFunction({status: 404, data: 'getSubListTestErrorMessage'} );
+ };
+ mockAaiService.getServices2 = (successFunction,failFunction) => {
+ failFunction({status: 404, data: 'getServices02TestErrorMessage'} );
+ };
+
+ // when
+ $scope.getSubs();
+
+ // then
+ expect( $scope.errorDetails ).toEqual('getServices02TestErrorMessage');
+ });
+
+ test('Verify refreshServiceTypes will call getServiceTypesList and gets service type list from AaiService, with proper customerID ', () => {
+ // given
+ dataService.setGlobalCustomerId('testCustomerID');
+ dataService.setServiceIdList(['testServiceId1','testServiceId2']);
+
+ mockAaiService.getSubscriptionServiceTypeList = (customerId, successFunction,failFunction) => {
+ if (customerId === 'testCustomerID'){
+ successFunction(['testServiceType1', 'testServiceType2']);
+ }
+ };
+
+ // when
+ $scope.refreshServiceTypes('testCustomerID');
+
+ // then
+ expect( $scope.serviceTypeList ).toContain('testServiceType1','testServiceType2');
+ });
+
+ test('Verify refreshServiceTypes will call getServiceTypesList and return error message with wrong customerID ', () => {
+ // given
+ mockAaiService.getSubscriptionServiceTypeList = (customerId, successFunction,failFunction) => {
+ if (customerId === 'testWrongCustomerID'){
+ failFunction( {status: 404, data: 'testErrorMessage'} );
+ }
+ };
+
+ // when
+ $scope.refreshServiceTypes('testWrongCustomerID');
+
+ // then
+ expect( $scope.errorDetails ).toEqual('testErrorMessage');
+ });
+
+ test('Verify refreshServiceTypes will call getServiceTypesList and calls alert with no customerID ', () => {
+ // given
+ alert = jestMock.fn();
+
+ // when
+ $scope.refreshServiceTypes('');
+
+ // then
+ expect( alert ).toHaveBeenCalledWith(mockFIELD.ERROR.SELECT);
+ });
+
+ test('Verify getAaiServiceModels will set correct location ', () => {
+ // given
+ mockLocation.path = jestMock.fn();
+
+ // when
+ $scope.getAaiServiceModels('testServiceType','testSubName');
+
+ // then
+ expect(mockLocation.path).toHaveBeenCalledWith(mockCOMPONENT.CREATE_INSTANCE_PATH);
+ });
+
+ test('Verify getAaiServiceModels wont set correct location if service type is empty', () => {
+ // given
+ mockLocation.path = jestMock.fn();
+
+ // when
+ $scope.getAaiServiceModels('','testSubName');
+
+ // then
+ expect(mockLocation.path).not.toHaveBeenCalled();
+ });
+
+ test('Verify getAaiServiceModelsList will call AaiService getServiceModelsByServiceType and will set wholeData ', () => {
+ // given
+
+ mockAaiService.getServiceModelsByServiceType = (queryId,customerId,serviceType,successFunction,failFunction) => {
+ let response = {};
+ response.data = {};
+ response.data['inventory-response-item'] = [[],[]];
+ response.data['inventory-response-item'][0]['inventory-response-items'] = [];
+ response.data['inventory-response-item'][0]['service-subscription'] = [];
+
+ let testItem = [];
+ testItem['extra-properties'] = [];
+ testItem['extra-properties']['extra-property'] = [[],[],[],[],[],[],[]];
+ testItem['extra-properties']['extra-property'][6]["property-value"] = 1.546;
+
+ testItem['extra-properties']['extra-property'][4]['property-value'] = 0;
+
+ response.data['inventory-response-item'][0]['service-subscription']['service-type'] = 'testServiceType';
+ response.data['inventory-response-item'][0]['inventory-response-items']['inventory-response-item'] = testItem;
+
+
+ successFunction(response);
+ };
+
+ mock_.reduce = (service,iterateeFunction,accumulatorFunction) => {
+ return iterateeFunction([],service);
+ };
+ mock_.forEach = (service,iterateeFunction) => {
+ iterateeFunction(service);
+ };
+ mock_.maxBy = (item,maxFunction) => {
+ return maxFunction( item[0][0] )
+ };
+
+ dataService.setServiceIdList(['testService1','testService2','testService3','testService4']);
+ dataService.setSubscribers([{subscriberName:'testSubscriber1'},{subscriberName:'testSubscriber2'},{subscriberName:'testSubscriber3'},{subscriberName:'testSubscriber4'}]);
+ dataService.setGlobalCustomerId(2);
+ dataService.setSubscriberName('testSubscriber1');
+
+ // when
+ $scope.getAaiServiceModelsList();
+
+ // then
+ expect($scope.services[0]).toEqual(1.546);
+ expect($scope.serviceType).toEqual('testServiceType');
+ });
+
+ test('Verify getAaiServiceModelsList will call AaiService getServiceModelsByServiceType and will return error data on fail ', () => {
+ // given
+ dataService.setServiceIdList([['testServiceId1','testServiceId2']]);
+ dataService.setSubscribers(['testSubscriber1,testSubscriber2']);
+
+ mockAaiService.getServiceModelsByServiceType = (queryId,customerId,serviceType,successFunction,failFunction) => {
+ failFunction( {status: 404, data: 'testErrorMessage'})
+ };
+
+ // when
+ $scope.getAaiServiceModelsList();
+
+ // then
+ expect($scope.errorDetails).toEqual('testErrorMessage');
+ });
+
+ test('Verify getAaiServiceModelsList will call AaiService getServiceModelsByServiceType and will return error data if respose data is empty ', () => {
+ // given
+ dataService.setServiceIdList([['testServiceId1','testServiceId2']]);
+ dataService.setSubscribers(['testSubscriber1,testSubscriber2']);
+
+ mockAaiService.getServiceModelsByServiceType = (queryId,customerId,serviceType,successFunction,failFunction) => {
+ let response = {};
+ response.data = {};
+ response.data['inventory-response-item'] = [];
+ successFunction(response);
+ };
+
+ // when
+ $scope.getAaiServiceModelsList();
+
+ // then
+ expect($scope.status).toEqual('Failed to get service models from SDC.');
+ });
+
+ test('Verify deployService will call http get method to rest model service', () => {
+ // given
+ mockedLog.error = jestMock.fn();
+ mockAsdcService.isMacro = (item) => { return true };
+ mockAsdcService.shouldTakeTheAsyncInstantiationFlow = (serviceModel) => {return 'testModel'};
+ mockUtilityService.convertModel = (serviceModel)=>{return serviceModel};
+ $scope.$broadcast = (broadcastType, broadcastObject) => {broadcastObject.callbackFunction(
+ {
+ isSuccessful:true,
+ control:
+ [
+ {id:"subscriberName",value:"testSubscriber"},
+ {id:"serviceType",value:"testService"}
+ ],
+ instanceId:"testInstance"
+ })};
+
+ let service = {
+ "service-instance":{
+ "model-version-id": 101
+ }
+ };
+
+ $scope.refreshSubs = jestMock.fn();
+
+ let mockedGetPromise = Promise.resolve({data: {service: {name: 'testServiceName' }}});
+ mockHttp.get = () => mockedGetPromise;
+
+ // when
+ $scope.deployService(service,true);
+ });
+
+ test('Verify deployService will log error if get fails ', () => {
+ // given
+
+ let mockedGetPromise = Promise.reject({code: 404});
+ mockHttp.get = () => mockedGetPromise;
+
+ let service = {
+ "service-instance":{
+ "model-version-id": 101
+ }
+ };
+
+ // when
+ $scope.deployService(service,false);
+ });
+
+ test('Verify refreshSubs fetches Subs and Services', () => {
+ // given
+ $scope.fetchSubs = jestMock.fn();
+ $scope.fetchServices = jestMock.fn();
+ $scope.init = jestMock.fn();
+
+ mockFIELD.PROMPT.REFRESH_SUB_LIST = 'testRefreshMock';
+
+ // when
+ $scope.refreshSubs();
+
+ // then
+ expect($scope.init).toHaveBeenCalled();
+ expect($scope.fetchSubs).toHaveBeenCalledWith(mockFIELD.PROMPT.REFRESH_SUB_LIST);
+ expect($scope.fetchServices).toHaveBeenCalled();
+
+ });
+
+ test('Verify loadOwningEntity gets owning entity properties', () => {
+ // given
+ mockOwningEntityService.getOwningEntityProperties = (callBack) => {
+ callBack({owningEntity:'testOwner',project:'testProject'});
+ };
+
+ // when
+ $scope.loadOwningEntity();
+
+ // then
+ expect($scope.owningEntities).toEqual('testOwner');
+ expect($scope.projects).toEqual('testProject');
+ });
+
+ test('Verify getPermitted returns items permission', () => {
+ // given
+ mockFIELD.ID.IS_PERMITTED = 'testPermission';
+
+ // when
+ expect(
+ $scope.getPermitted({})
+ ).toEqual(undefined);
+
+ expect(
+ $scope.getPermitted({isPermitted:true})
+ ).toEqual(true);
+
+ expect(
+ $scope.getPermitted({isPermitted:false})
+ ).toEqual(undefined);
+
+ expect(
+ $scope.getPermitted({isPermitted:false,testPermission:true})
+ ).toEqual(true);
+
+ expect(
+ $scope.getPermitted({testPermission:false,testPermission:false})
+ ).toEqual(false);
+
+ expect(
+ $scope.getPermitted({isPermitted:true,testPermission:false})
+ ).toEqual(true);
+ });
+
+ test('Verify getSubDetails calls to aaiService for service instance', () => {
+ // given
+ let aaiPromise = Promise.resolve(
+ {
+ displayData:[
+ {globalCustomerId:"testCustomerId01",subscriberName:"testCustomer1"},
+ {globalCustomerId:"testCustomerId02",subscriberName:"testCustomer2"},
+ ]
+ });
+
+ mockLocation.url = () => {return ""};
+
+ mockAaiService.searchServiceInstances = (query)=>aaiPromise;
+
+ // when
+ $scope.getSubDetails();
+ });
+
+ test('Verify getSubDetails catches bad response', () => {
+ // given
+ let aaiPromise = Promise.reject(
+ {data:'testError',status:404});
+
+ mockLocation.url = () => {return ""};
+
+ mockAaiService.searchServiceInstances = (query)=>aaiPromise;
+
+ // when
+ $scope.getSubDetails();
+ });
+
+ test('Verify getComponentList returns list of components if query is correct', () => {
+ // given
+ mockLocation.search = () => {
+ return {
+ subscriberId: 'testSubscriberID',
+ serviceType: 'testService',
+ serviceInstanceId: "testServiceInstanceID",
+ subscriberName: "testSubscriber",
+ aaiModelVersionId: "testModelVersion"
+ }
+ };
+
+ mockVidService.getModel = () => {
+ return {
+ service:{
+ uuid: "testModelVersion",
+ },
+ }
+ };
+
+ mockUtilityService.hasContents = (content) => {
+ if (content==="testModelVersion") {
+ return true;
+ }
+ return false;
+ };
+
+ mockQ.resolve = (item) => {return Promise.resolve("testModelVersion")};
+
+ $scope.prepareScopeWithModel = () => {return Promise.resolve()};
+
+ mockAaiService.getVlansByNetworksMapping = (globalCustomerId, serviceType, serviceInstanceId, modelServiceUuid) => {
+ return Promise.resolve({serviceNetworks:true});
+ };
+
+ $scope.service ={
+ model:{
+ service:{
+ uuid: 'testModelServiceUuid'
+ }
+ }
+ };
+
+ mockedLog.debug = () => {};
+ mockUtilityService.isObjectEmpty = () => {
+ return false;
+ };
+
+ mockFIELD.ID.INVENTORY_RESPONSE_ITEM = "testResponseItems";
+ mockFIELD.ID.SERVICE_SUBSCRIPTION = 0;
+ mockFIELD.ID.SERVICE_INSTANCES = 0;
+ mockFIELD.ID.SERVICE_INSTANCE = 0;
+ mockFIELD.ID.SERVICE_INSTANCE_ID = 'testServiceInstanceID';
+ mockFIELD.STATUS.ASSIGNED = 'teststatus';
+
+ mockAaiService.runNamedQuery = (namedQueryId,globalCustomerId,serviceType,serviceInstanceId,successFunction,failureFunction) => {
+ successFunction({
+ data:{
+ testResponseItems:[
+ "testItem1",
+ "testItem2",
+ "testItem3",
+ ]
+ },
+ });
+ return Promise.resolve("testComponentList");
+ };
+
+ mockAaiService.getPortMirroringData = (portMirroringConfigurationIds) => {
+ return Promise.resolve({data:[8080,9090]});
+ };
+
+ mockAaiService.getPortMirroringSourcePorts = (portMirroringConfigurationIds) => {
+ return Promise.resolve({data:[8888,9999]})
+ };
+
+ mockAaiService.getSubscriberName = (customerId, successFunction) => {
+ successFunction({subscriberName:"testSubscriber1",serviceSubscriptions:[[
+ [[[{'testServiceInstanceID':'testServiceInstanceID','orchestration-status':'testStatus'},{'testServiceInstanceID':'','orchestration-status':''}]]],
+ [[[{'testServiceInstanceID':'','orchestration-status':''}]]]
+ ]],
+ });
+ };
+
+ mock_.map = (serviceNetworkVlans, networkId) => {
+ return ["aaiNetworkId1","aaiNetworkId2"];
+ };
+
+ // when
+ return $scope.getComponentList('','').
+ then(components =>{
+ expect(components).toEqual("testComponentList")
+ });
+
+ });
+
+ test('Verify handleServerError sets proper $scope.error and $scope.status', () => {
+ // given
+ mockUtilityService.getHttpErrorMessage = (response) => {return response.statusText};
+ mockFIELD.ERROR.SYSTEM_ERROR = "testSystemError";
+ mockFIELD.STATUS.ERROR = "testStatusError";
+
+ // when
+ $scope.handleServerError({statusText:'testStatusError'},'');
+
+ // then
+ expect($scope.error).toEqual("testSystemError (testStatusError)");
+ expect($scope.status).toEqual("testStatusError");
+ });
+
+ test('Verify showContentError sets proper $scope.error and $scope.status if UtilityService has that content', () => {
+ // given
+ mockFIELD.STATUS.ERROR = "testStatusError";
+
+ mockUtilityService.hasContents = (content) => {
+ return content === 'testContentError';
+
+ };
+
+ // when
+ $scope.showContentError('testContentError');
+
+ // then
+ expect($scope.error).toEqual("System failure (testContentError)");
+ expect($scope.status).toEqual("testStatusError");
+ });
+
+ test('Verify showContentError sets proper $scope.error and $scope.status if UtilityService has not that content', () => {
+ // given
+ mockFIELD.ERROR.SYSTEM_ERROR = "testSystemError";
+ mockFIELD.STATUS.ERROR = "testStatusError";
+
+ mockUtilityService.hasContents = (content) => {
+ return false;
+ };
+
+ // when
+ $scope.showContentError('testContentError');
+
+ // then
+ expect($scope.error).toEqual("testSystemError");
+ expect($scope.status).toEqual("testStatusError");
+ });
+
+ test('Verify handleInitialResponse shows error for response codes other then 200,201,202', () => {
+ // given
+ let response = {
+ data:{
+ status:404,
+ }
+ };
+
+ mockFIELD.ERROR.MSO = "testSystemError";
+ mockFIELD.ERROR.AAI_FETCHING_CUST_DATA = "testStatusError:";
+
+ $scope.showError = jestMock.fn();
+
+ // when
+ $scope.handleInitialResponse(response);
+
+ // then
+ expect($scope.showError).toHaveBeenCalledWith("testSystemError");
+ expect($scope.status).toEqual("testStatusError:404");
+ });
+
+ test('Verify handleInitialResponse updates customer list with response code 202', () => {
+ // given
+ let customer ={
+ 'globalCustomerId':'testCustomerID',
+ "subscriberName":'testSubscriber',
+ "isPermitted":false
+ };
+ let response = {
+ data:{
+ status:202,
+ customer:[customer],
+ }
+ };
+
+ mockFIELD.ID.GLOBAL_CUSTOMER_ID = 'globalCustomerId';
+ mockFIELD.ID.SUBNAME = 'subscriberName';
+ mockFIELD.ID.IS_PERMITTED = 'isPermitted';
+
+ // when
+ $scope.handleInitialResponse(response);
+
+ // then
+ expect($scope.customerList).toContainEqual(customer);
+ });
+
+ test('Verify handleInitialResponse calls showContentError with wrong response ', () => {
+ // given
+ $scope.showContentError = jestMock.fn();
+
+ // when
+ $scope.handleInitialResponse(null);
+
+ // then
+ expect($scope.showContentError).toHaveBeenCalledWith(expect.objectContaining({message:"Cannot read property 'data' of null"}));
+ });
+
+ test('Verify isConfigurationDataAvailiable will return proper response', () => {
+ // given
+ mockedLog.debug = jestMock.fn();
+ // when
+ expect( $scope.isConfigurationDataAvailiable({configData:{}}) ).toEqual(true);
+ expect( $scope.isConfigurationDataAvailiable({configData:{errorDescription:"testerror"}}) ).toEqual(false);
+ expect( $scope.isConfigurationDataAvailiable({}) ).toEqual(undefined);
+
+ });
+
+ test('Verify isActivateDeactivateEnabled will return proper response', () => {
+ // given
+ mockedLog.debug = jestMock.fn();
+
+ $scope.serviceOrchestrationStatus = "active";
+ mockCOMPONENT.ACTIVATE_SERVICE_STATUSES = ["active","up"];
+
+ // when
+ expect( $scope.isActivateDeactivateEnabled("deactivate")).toEqual(true);
+ expect( $scope.isActivateDeactivateEnabled("activate")).toEqual(true);
+
+ $scope.serviceOrchestrationStatus = "down";
+ mockCOMPONENT.ACTIVATE_SERVICE_STATUSES = ["active","up"];
+
+ expect( $scope.isActivateDeactivateEnabled("deactivate")).toEqual(false);
+ expect( $scope.isActivateDeactivateEnabled("activate")).toEqual(false);
+
+ $scope.serviceOrchestrationStatus = null;
+
+ expect( $scope.isActivateDeactivateEnabled(null)).toEqual(false);
+
+ });
+
+ test('Verify isShowVerifyService will return proper response base on feature flag', () => {
+ // given
+ mockCOMPONENT.FEATURE_FLAGS.FLAG_SHOW_VERIFY_SERVICE = 'showVerifyService';
+ mockFeatureFlags.isOn = (flag) => {
+ if (flag === 'showVerifyService'){return true};
+ };
+
+ // when
+ expect( $scope.isShowVerifyService()).toEqual(true);
+ });
+
+ test('Verify isEnableVerifyService will return false if is not ALaCarte', () => {
+ // given
+ dataService.setALaCarte(false);
+
+ // when
+ expect( $scope.isEnableVerifyService()).toEqual(false);
+ });
+
+ test('Verify isEnableVerifyService will return verifyButtonEnabled if is ALaCarte', () => {
+ // given
+ dataService.setALaCarte(true);
+
+ // when
+ $scope.verifyButtonEnabled = true;
+ expect( $scope.isEnableVerifyService()).toEqual(true);
+
+ $scope.verifyButtonEnabled = false;
+ expect( $scope.isEnableVerifyService()).toEqual(false);
+ });
+
+ test('Verify activateVerifyService will post POMBA verification', () => {
+ // given
+ mockCOMPONENT.VERIFY_SERVICE_URL = "/testURL";
+
+ mockAaiService.postPOMBAverificationRequest = jestMock.fn();
+
+ $scope.serviceInstanceId = "testInstanceID";
+ $scope.service = {model:{service:{}},instance:{}};
+ $scope.service.model.service.uuid = "testUuid";
+ $scope.service.model.service.invariantUuid = "testInvariantUuid";
+ $scope.globalCustomerId = "testCustomerId";
+ $scope.service.instance.serviceType = "testServiceType";
+
+ // when
+ $scope.activateVerifyService();
+
+ // then
+ expect(mockAaiService.postPOMBAverificationRequest).toHaveBeenCalledWith(
+ "/testURL",
+ expect.objectContaining({'serviceInstanceList':[expect.any(Object)]}),
+ expect.objectContaining({'headers':expect.any(Object)}));
+ });
+
+ test('Verify isShowAssignmentsEnabled will return proper response determine by feature flag', () => {
+ // given
+ mockCOMPONENT.FEATURE_FLAGS.FLAG_SHOW_ASSIGNMENTS = "showAssignment";
+
+ mockFeatureFlags.isOn = (flag) => {
+ if (flag === 'showAssignment'){return true};
+ };
+
+ // when
+ $scope.serviceOrchestrationStatus = "assigned";
+ expect( $scope.isShowAssignmentsEnabled() ).toEqual(true);
+
+ $scope.serviceOrchestrationStatus = "notAssigned";
+ expect( $scope.isShowAssignmentsEnabled() ).toEqual(false);
+
+ $scope.serviceOrchestrationStatus = null;
+ expect( $scope.isShowAssignmentsEnabled() ).toEqual(false);
+ });
+
+ test('Verify isActivateFabricConfiguration will return proper response determine by feature flag', () => {
+ // given
+ mockCOMPONENT.FEATURE_FLAGS.FLAG_FABRIC_CONFIGURATION_ASSIGNMENTS = "fabricConfigurationAssignment";
+ $scope.hasFabricConfigurations = true;
+
+ mockFeatureFlags.isOn = (flag) => {
+ if (flag === 'fabricConfigurationAssignment'){return true};
+ };
+
+ // when
+ $scope.serviceOrchestrationStatus = "assigned";
+ expect( $scope.isActivateFabricConfiguration() ).toEqual(true);
+
+ $scope.serviceOrchestrationStatus = "notAssigned";
+ expect( $scope.isActivateFabricConfiguration() ).toEqual(false);
+
+ $scope.serviceOrchestrationStatus = null;
+ expect( $scope.isActivateFabricConfiguration() ).toEqual(false);
+ });
+
+ test('Verify isResumeShown will return proper response determine by feature flag with disabled ActivateDeactivate', () => {
+ // given
+ $scope.serviceOrchestrationStatus = "assigned";
+ $scope.isActivateDeactivateEnabled = () => {return false};
+
+ // when
+ expect( $scope.isResumeShown("assigned") ).toEqual(true);
+ expect( $scope.isResumeShown("unAssigned") ).toEqual(false);
+
+ });
+
+ test('Verify isResumeShown will return proper response determine by feature flag with enable ActivateDeactivate', () => {
+ // given
+ $scope.serviceOrchestrationStatus = "assigned";
+ $scope.isActivateDeactivateEnabled = () => {return true};
+
+ // when
+ expect( $scope.isResumeShown("assigned") ).toEqual(false);
+ expect( $scope.isResumeShown("unAssigned") ).toEqual(false);
+
+ });
+
+ test('Verify close will call time out cancel and hides pop up window if timer is defined', () => {
+ // given
+ $scope.timer = 1000;
+ $scope.isPopupVisible = true;
+
+ timeout.cancel = jestMock.fn();
+
+ // when
+ $scope.close();
+
+ // then
+ expect(timeout.cancel).toHaveBeenCalledWith(1000);
+ expect($scope.isPopupVisible).toEqual(false);
+ });
+
+ test('Verify close will hide pop up window if timer is undefined', () => {
+ // given
+ $scope.timer = undefined;
+ $scope.isPopupVisible = true;
+
+ // when
+ $scope.close();
+
+ // then
+ expect($scope.isPopupVisible).toEqual(false);
+ });
+
+ test('Verify reloadRoute will call reload on rout', () => {
+ // given
+ mockRoute.reload = jestMock.fn();
+
+ // when
+ $scope.reloadRoute();
+
+ // then
+ expect(mockRoute.reload).toHaveBeenCalled();
+ });
+
+ test('Verify prevPage will decrease currentPage', () => {
+ // given
+ $scope.currentPage = 5;
+
+ // when
+ $scope.prevPage();
+
+ // then
+ expect($scope.currentPage).toEqual(4);
+ });
+
+ test('Verify showAssignmentsSDNC will return proper response base on VIDCONFIGURATION', () => {
+ // given
+ $scope.service = {};
+ $scope.service.instance = {};
+ $scope.service.instance.id = "testServiceInstanceId";
+
+ mockVIDCONFIGURATION.SDNC_SHOW_ASSIGNMENTS_URL = "test/ulr/to/<SERVICE_INSTANCE_ID>";
+
+ // when
+ expect( $scope.showAssignmentsSDNC() ).toEqual("test/ulr/to/testServiceInstanceId");
+ });
+
+ test('Verify showAssignmentsSDNC will return null if service instance dos not exist or is null', () => {
+ // given
+ $scope.service = {};
+
+ // when
+ expect( $scope.showAssignmentsSDNC() ).toEqual(null);
+
+ $scope.service.instance = null;
+ expect( $scope.showAssignmentsSDNC() ).toEqual(null);
+ });
+
+ test('Verify activateFabricConfigurationMSO with logged in user, will call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ mockCOMPONENT.MSO_ACTIVATE_FABRIC_CONFIGURATION_REQ = "testMsoActivateType";
+
+ $scope.service = {};
+ $scope.service.model = {};
+ $scope.service = {};
+ $scope.serviceInstanceId= "testServiceInstanceId";
+
+ dataService.setLoggedInUserId("testUserId");
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ // when
+ $scope.activateFabricConfigurationMSO();
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoActivateType");
+ expect( resopnse.requestParams().serviceInstanceId ).toEqual("testServiceInstanceId");
+ expect( resopnse.requestParams().userId ).toEqual("testUserId");
+ expect( resopnse.configuration() ).toEqual(undefined);
+ });
+
+ test('Verify activateFabricConfigurationMSO without logged in user will first get user id from AaiService , will call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ mockCOMPONENT.MSO_ACTIVATE_FABRIC_CONFIGURATION_REQ = "testMsoActivateType";
+
+ $scope.service = {};
+ $scope.service.model = {};
+ $scope.service = {};
+ $scope.serviceInstanceId= "testServiceInstanceId";
+
+
+ mockAaiService.getLoggedInUserID = (onSuccess) => {
+ onSuccess({data:"testAaiUserId"});
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ // when
+ $scope.activateFabricConfigurationMSO();
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoActivateType");
+ expect( resopnse.requestParams().serviceInstanceId ).toEqual("testServiceInstanceId");
+ expect( resopnse.requestParams().userId ).toEqual("testAaiUserId");
+ expect( resopnse.configuration() ).toEqual(undefined);
+ });
+
+ test('Verify activateMSOInstance with logged in user, will get aicZone from AaiService and call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ mockCOMPONENT.MSO_ACTIVATE_SERVICE_REQ = "testMsoActivateType";
+
+ $scope.service = {};
+ $scope.service.model = {};
+ $scope.service.instance = {};
+
+ dataService.setLoggedInUserId("testUserId");
+
+ mockAaiService.getAicZoneForPNF = (globalCustomerId,serviceType,serviceInstanceId,getZoneFunction) => {
+ getZoneFunction("testAicZone");
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ // when
+ $scope.activateMSOInstance();
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoActivateType");
+ expect( resopnse.requestParams().aicZone ).toEqual("testAicZone");
+ expect( resopnse.requestParams().userId ).toEqual("testUserId");
+ expect( resopnse.configuration() ).toEqual(undefined);
+ });
+
+ test('Verify activateMSOInstance without logged in user will first get user id from AaiService , will call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ mockCOMPONENT.MSO_ACTIVATE_SERVICE_REQ = "testMsoActivateType";
+
+ $scope.service = {};
+ $scope.service.model = {};
+ $scope.service.instance = {};
+
+
+ mockAaiService.getAicZoneForPNF = (globalCustomerId,serviceType,serviceInstanceId,getZoneFunction) => {
+ getZoneFunction("testAicZone");
+ };
+
+ mockAaiService.getLoggedInUserID = (onSuccess) => {
+ onSuccess({data:"testAaiUserId"});
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ // when
+ $scope.activateMSOInstance();
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoActivateType");
+ expect( resopnse.requestParams().aicZone ).toEqual("testAicZone");
+ expect( resopnse.requestParams().userId ).toEqual("testAaiUserId");
+ expect( resopnse.configuration() ).toEqual(undefined);
+ });
+
+ test('Verify deactivateMSOInstance will get call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ mockCOMPONENT.MSO_DEACTIVATE_SERVICE_REQ = "testMsoDeactivateType";
+
+ $scope.service = {};
+ $scope.service.model = {};
+ $scope.service.instance = {};
+
+
+ mockAaiService.getAicZoneForPNF = (globalCustomerId,serviceType,serviceInstanceId,getZoneFunction) => {
+ getZoneFunction("testAicZone");
+ };
+
+ mockAaiService.getLoggedInUserID = (onSuccess) => {
+ onSuccess({data:"testAaiUserId"});
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ // when
+ $scope.deactivateMSOInstance();
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoDeactivateType");
+ expect( resopnse.requestParams().aicZone ).toEqual("testAicZone");
+ expect( resopnse.requestParams().userId ).toEqual("testAaiUserId");
+ expect( resopnse.configuration() ).toEqual(undefined);
+ });
+
+ test('Verify deleteConfiguration will get call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ serviceObject = {
+ model:{
+ service:{
+ invariantUuid:"testInvariantUuid",
+ uuid:"testUuid",
+ name:"testService",
+ version:"testVersion",
+ }},
+ instance:{
+ serviceInstanceId:"testServiceInstanceId",
+ }
+ };
+
+ configuration = {
+ modelInvariantId:"testModelInvariantId",
+ modelVersionId:"testModelVersionId",
+ modelCustomizationId:"testModelCustomizationId",
+ nodeId:"testNodeId",
+ DELETE:"testDELETE",
+ };
+
+ mockCOMPONENT.MSO_DELETE_CONFIGURATION_REQ = "testMsoDeleteType";
+
+ mockAaiService.getLoggedInUserID = (successFunction) => {
+ successFunction( {data:"testLoggedInUserId"} );
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ // when
+ $scope.deleteConfiguration(serviceObject, configuration);
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoDeleteType");
+ expect( resopnse.requestParams().serviceModel.modelInvariantId ).toEqual("testInvariantUuid");
+ expect( resopnse.requestParams().serviceModel.modelVersionId ).toEqual("testUuid");
+ expect( resopnse.requestParams().serviceModel.modelName ).toEqual("testService");
+ expect( resopnse.requestParams().serviceModel.modelVersion ).toEqual("testVersion");
+ expect( resopnse.requestParams().serviceInstanceId ).toEqual("testServiceInstanceId");
+ expect( resopnse.requestParams().configurationModel.modelInvariantId ).toEqual("testModelInvariantId");
+ expect( resopnse.requestParams().configurationModel.modelVersionId ).toEqual("testModelVersionId");
+ expect( resopnse.requestParams().configurationModel.modelCustomizationId ).toEqual("testModelCustomizationId");
+ expect( resopnse.requestParams().configurationId ).toEqual("testNodeId");
+ expect( resopnse.requestParams().configStatus ).toEqual("testDELETE");
+ expect( resopnse.requestParams().userId ).toEqual("testLoggedInUserId");
+ });
+
+ test('Verify toggleConfigurationStatus will get call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ serviceObject = {
+ model:{
+ service:{
+ invariantUuid:"testInvariantUuid",
+ uuid:"testUuid",
+ name:"testService",
+ version:"testVersion",
+ }},
+ instance:{
+ serviceInstanceId:"testServiceInstanceId",
+ }
+ };
+
+ configuration = {
+ modelInvariantId:"testModelInvariantId",
+ modelVersionId:"testModelVersionId",
+ modelCustomizationId:"testModelCustomizationId",
+ nodeId:"testNodeId",
+ nodeStatus:"testNodeStatus",
+ };
+
+ mockAaiService.getLoggedInUserID = (successFunction) => {
+ successFunction( {data:"testLoggedInUserId"} );
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ mockCOMPONENT.MSO_CHANGE_CONFIG_STATUS_REQ = "testMsoChangeConfig";
+
+ // when
+ $scope.toggleConfigurationStatus(serviceObject, configuration);
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoChangeConfig");
+ expect( resopnse.requestParams().serviceModel.modelInvariantId ).toEqual("testInvariantUuid");
+ expect( resopnse.requestParams().serviceModel.modelVersionId ).toEqual("testUuid");
+ expect( resopnse.requestParams().serviceModel.modelName ).toEqual("testService");
+ expect( resopnse.requestParams().serviceModel.modelVersion ).toEqual("testVersion");
+ expect( resopnse.requestParams().serviceInstanceId ).toEqual("testServiceInstanceId");
+ expect( resopnse.requestParams().configurationModel.modelInvariantId ).toEqual("testModelInvariantId");
+ expect( resopnse.requestParams().configurationModel.modelVersionId ).toEqual("testModelVersionId");
+ expect( resopnse.requestParams().configurationModel.modelCustomizationId ).toEqual("testModelCustomizationId");
+ expect( resopnse.requestParams().configurationId ).toEqual("testNodeId");
+ expect( resopnse.requestParams().configStatus ).toEqual("testNodeStatus");
+ expect( resopnse.requestParams().userId ).toEqual("testLoggedInUserId");
+ });
+
+ test('Verify togglePortStatus will get call uibModal open that will return response ', () => {
+ // given
+ let resopnse = {};
+
+ let serviceObject = {
+ model:{
+ service:{
+ invariantUuid:"testInvariantUuid",
+ uuid:"testUuid",
+ name:"testService",
+ version:"testVersion",
+ }},
+ instance:{
+ serviceInstanceId:"testServiceInstanceId",
+ }
+ };
+
+ let configuration = {
+ modelInvariantId:"testModelInvariantId",
+ modelVersionId:"testModelVersionId",
+ modelCustomizationId:"testModelCustomizationId",
+ nodeId:"testNodeId",
+ };
+
+ let port = {
+ portId:"testPort",
+ portStatus:"open",
+ };
+
+ mockAaiService.getLoggedInUserID = (successFunction) => {
+ successFunction( {data:"testLoggedInUserId"} );
+ };
+
+ mockUibModal.open = (testResponse) => {
+ resopnse = testResponse.resolve;
+ };
+
+ mockCOMPONENT.MSO_CHANGE_PORT_STATUS_REQ = "testMsoPortStatus";
+
+ // when
+ $scope.togglePortStatus(serviceObject, configuration,port);
+
+ // then
+ expect( resopnse.msoType() ).toEqual("testMsoPortStatus");
+ expect( resopnse.requestParams().serviceModel.modelInvariantId ).toEqual("testInvariantUuid");
+ expect( resopnse.requestParams().serviceModel.modelVersionId ).toEqual("testUuid");
+ expect( resopnse.requestParams().serviceModel.modelName ).toEqual("testService");
+ expect( resopnse.requestParams().serviceModel.modelVersion ).toEqual("testVersion");
+ expect( resopnse.requestParams().serviceInstanceId ).toEqual("testServiceInstanceId");
+ expect( resopnse.requestParams().configurationModel.modelInvariantId ).toEqual("testModelInvariantId");
+ expect( resopnse.requestParams().configurationModel.modelVersionId ).toEqual("testModelVersionId");
+ expect( resopnse.requestParams().configurationModel.modelCustomizationId ).toEqual("testModelCustomizationId");
+ expect( resopnse.requestParams().configurationId ).toEqual("testNodeId");
+ expect( resopnse.requestParams().userId ).toEqual("testLoggedInUserId");
+ expect( resopnse.requestParams().portId ).toEqual("testPort");
+ expect( resopnse.requestParams().portStatus ).toEqual("open");
+ });
+
+
+ test('Verify getServiceInstancesSearchResults will get global customer Id from AaiService with proper service instance', () => {
+ // given
+ let selectedCustomer = 'testCustomer';
+ let selectedInstanceIdentifierType = 'testInstanceIdentifierType';
+ let selectedServiceInstance = 'testServiceInstance ';
+ let selectedProject = "testProject";
+ let selectedOwningEntity = "testOwningEntity";
+
+ let globalCustomerId = 'testCustomerIdResponse';
+
+ mockAaiService.getGlobalCustomerIdByInstanceIdentifier = jestMock.fn((serviceInstance, instanceIdentifierType) => {
+ if(serviceInstance===selectedServiceInstance && instanceIdentifierType == selectedInstanceIdentifierType){
+ return Promise.resolve(globalCustomerId);
+ }
+ return Promise.reject();
+ });
+
+ mockAaiService.getMultipleValueParamQueryString = ( element, subPath) => {
+ return subPath + '/ ' + element;
+ };
+
+ mockAaiService.getJoinedQueryString = jestMock.fn();
+
+ mock_.map = (element,id) => {
+ return element;
+ };
+
+ mockCOMPONENT.PROJECT_SUB_PATH = "test/project/sub";
+ mockCOMPONENT.OWNING_ENTITY_SUB_PATH = "test/entity/sub";
+ mockCOMPONENT.SELECTED_SUBSCRIBER_SUB_PATH = "test/subscriber/sub";
+ mockCOMPONENT.SELECTED_SERVICE_INSTANCE_SUB_PATH = "test/service/instance/sub";
+ mockCOMPONENT.SELECTED_SERVICE_SUB_PATH = "text/service/sub";
+
+ mockUtilityService.hasContents = (element) => {
+ if ( element === selectedCustomer ||
+ element === selectedServiceInstance ||
+ element === globalCustomerId )
+ return true;
+ };
+
+ window.location = {};
+
+ // when
+ $scope.getServiceInstancesSearchResults(selectedCustomer, selectedInstanceIdentifierType, selectedServiceInstance, selectedProject, selectedOwningEntity);
+
+ // then
+ expect(mockAaiService.getGlobalCustomerIdByInstanceIdentifier).toHaveBeenCalledWith(selectedServiceInstance,selectedInstanceIdentifierType);
+ });
+
+ test('Verify getServiceInstancesSearchResults will alert error if non of parameters is located in UtilityService', () => {
+ // given
+ let selectedCustomer = 'testCustomer';
+ let selectedInstanceIdentifierType = 'testInstanceIdentifierType';
+ let selectedServiceInstance = 'testServiceInstance ';
+ let selectedProject = "testProject";
+ let selectedOwningEntity = "testOwningEntity";
+
+ let globalCustomerId = 'testCustomerIdResponse';
+
+ mockAaiService.getGlobalCustomerIdByInstanceIdentifier = (serviceInstance, instanceIdentifierType) => {
+ if(serviceInstance===selectedServiceInstance && instanceIdentifierType == selectedInstanceIdentifierType){
+ return Promise.resolve(globalCustomerId);
+ }
+ return Promise.reject();
+ };
+
+ mockAaiService.getMultipleValueParamQueryString = ( element, subPath) => {
+ return subPath + '/ ' + element;
+ };
+
+ mockAaiService.getJoinedQueryString = (queryArray) => {
+ let joinedQuery = "";
+ queryArray.forEach((element)=>{
+ joinedQuery += element + "//"
+ });
+
+ return joinedQuery;
+ };
+
+ mock_.map = (element,id) => {
+ return element;
+ };
+
+ mockCOMPONENT.PROJECT_SUB_PATH = "test/project/sub";
+ mockCOMPONENT.OWNING_ENTITY_SUB_PATH = "test/entity/sub";
+ mockCOMPONENT.SELECTED_SUBSCRIBER_SUB_PATH = "test/subscriber/sub";
+ mockCOMPONENT.SELECTED_SERVICE_INSTANCE_SUB_PATH = "test/service/instance/sub";
+ mockCOMPONENT.SELECTED_SERVICE_SUB_PATH = "text/service/sub";
+
+ mockUtilityService.hasContents = (element) => {
+ return false;
+ };
+
+ alert = jestMock.fn();
+ mockFIELD.ERROR.SELECT = "testError";
+
+ window.location = {};
+
+ // when
+ $scope.getServiceInstancesSearchResults(selectedCustomer, selectedInstanceIdentifierType, selectedServiceInstance, selectedProject, selectedOwningEntity);
+
+ // then
+ expect(alert).toHaveBeenCalledWith("testError");
+ });
+
+ test('Verify getServiceInstancesSearchResults will navigate to proper page if selected service instance is not present in UtilityService', () => {
+ // given
+ let selectedCustomer = 'testCustomer';
+ let selectedInstanceIdentifierType = 'testInstanceIdentifierType';
+ let selectedServiceInstance = 'testServiceInstance ';
+ let selectedProject = "testProject";
+ let selectedOwningEntity = "testOwningEntity";
+
+ let globalCustomerId = 'testCustomerIdResponse';
+
+ mockAaiService.getGlobalCustomerIdByInstanceIdentifier = (serviceInstance, instanceIdentifierType) => {
+ if(serviceInstance===selectedServiceInstance && instanceIdentifierType == selectedInstanceIdentifierType){
+ return Promise.resolve(globalCustomerId);
+ }
+ return Promise.reject();
+ };
+
+ mockAaiService.getMultipleValueParamQueryString = ( element, subPath) => {
+ return subPath + element;
+ };
+
+ mockAaiService.getJoinedQueryString = jestMock.fn();
+
+ mock_.map = (element,id) => {
+ return element;
+ };
+
+ mockCOMPONENT.PROJECT_SUB_PATH = "test/project/sub/";
+ mockCOMPONENT.OWNING_ENTITY_SUB_PATH = "test/entity/sub/";
+ mockCOMPONENT.SELECTED_SUBSCRIBER_SUB_PATH = "test/subscriber/sub/";
+ mockCOMPONENT.SELECTED_SERVICE_INSTANCE_SUB_PATH = "test/service/instance/sub/";
+ mockCOMPONENT.SELECTED_SERVICE_SUB_PATH = "text/service/sub/";
+
+
+ mockUtilityService.hasContents = (element) => {
+ return element === selectedCustomer;
+ };
+
+ window.location = {};
+
+ // when
+ $scope.getServiceInstancesSearchResults(selectedCustomer, selectedInstanceIdentifierType, selectedServiceInstance, selectedProject, selectedOwningEntity);
+
+ // then
+ expect(mockAaiService.getJoinedQueryString).toHaveBeenCalledWith(expect.arrayContaining([
+ mockCOMPONENT.PROJECT_SUB_PATH+selectedProject,
+ mockCOMPONENT.OWNING_ENTITY_SUB_PATH+selectedOwningEntity,
+ mockCOMPONENT.SELECTED_SUBSCRIBER_SUB_PATH+selectedCustomer
+ ]));
+ });
+
+
+});
\ No newline at end of file