openecomp-ui/test/softwareProduct/components/network/SoftwareProductComponentsNetworkActionHelper.test.js

   1 /*!
   2  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  13  * or implied. See the License for the specific language governing
  14  * permissions and limitations under the License.
  15  */
  16 import deepFreeze from 'deep-freeze';
  17 import mockRest from 'test-utils/MockRest.js';
  18 import {cloneAndSet} from 'test-utils/Util.js';
  19 import {storeCreator} from 'sdc-app/AppStore.js';
  20 import SoftwareProductComponentsNetworkActionHelper from 'sdc-app/onboarding/softwareProduct/components/network/SoftwareProductComponentsNetworkActionHelper.js';
  21
  22 import {VSPComponentsNicFactory, VSPComponentsNetworkFactory, VSPComponentsNetworkQDataFactory, VSPComponentsNetworkDataMapFactory, VSPComponentsNicFactoryGenericFieldInfo} from 'test-utils/factories/softwareProduct/SoftwareProductComponentsNetworkFactories.js';
  23 import VersionControllerUtilsFactory from 'test-utils/factories/softwareProduct/VersionControllerUtilsFactory.js';
  24 import VSPQSchemaFactory from 'test-utils/factories/softwareProduct/SoftwareProductQSchemaFactory.js';
  25 import {forms} from 'sdc-app/onboarding/softwareProduct/components/SoftwareProductComponentsConstants.js';
  26
  27 const softwareProductId = '123';
  28 const componentId = '321';
  29 const nicId = '111';
  30 const version = VersionControllerUtilsFactory.build().version;
  31
  32 describe('Software Product Components Network Action Helper Tests', function () {
  33
  34         it('Fetch NICs List', () => {
  35                 const store = storeCreator();
  36                 deepFreeze(store.getState());
  37
  38                 const NICList = VSPComponentsNicFactory.buildList(2);
  39
  40                 deepFreeze(NICList);
  41
  42                 deepFreeze(store.getState());
  43
  44                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network.nicList', NICList);
  45
  46                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  47                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics`);
  48                         expect(data).toEqual(undefined);
  49                         expect(options).toEqual(undefined);
  50                         return {results: NICList};
  51                 });
  52
  53                 return SoftwareProductComponentsNetworkActionHelper.fetchNICsList(store.dispatch, {softwareProductId, version, componentId}).then(() => {
  54                         expect(store.getState()).toEqual(expectedStore);
  55                 });
  56
  57         });
  58
  59         it('open NICE editor', () => {
  60
  61                 const store = storeCreator();
  62                 deepFreeze(store.getState());
  63                 const data = VSPComponentsNicFactory.build();
  64                 const genericFieldInfo = VSPComponentsNicFactoryGenericFieldInfo.build();
  65
  66                 const nic = {id: '444'};
  67                 deepFreeze(data);
  68                 deepFreeze(nic);
  69
  70                 const expectedData = {...data, id: nic.id};
  71
  72                 deepFreeze(expectedData);
  73
  74                 const network = VSPComponentsNetworkFactory.build({
  75                         nicEditor: {
  76                                 data: expectedData,
  77                                 formName: forms.NIC_EDIT_FORM,
  78                                 genericFieldInfo
  79                         }
  80                 });
  81
  82                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
  83
  84                 SoftwareProductComponentsNetworkActionHelper.openNICEditor(store.dispatch, {nic, data});
  85
  86                 expect(store.getState()).toEqual(expectedStore);
  87         });
  88
  89         it('close NICE editor', () => {
  90
  91                 const store = storeCreator();
  92                 deepFreeze(store.getState());
  93
  94                 const network = VSPComponentsNetworkFactory.build();
  95                 deepFreeze(network);
  96
  97                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
  98
  99                 SoftwareProductComponentsNetworkActionHelper.closeNICEditor(store.dispatch);
 100
 101                 expect(store.getState()).toEqual(expectedStore);
 102         });
 103
 104         it('Load NIC data', () => {
 105
 106                 const expectedData = VSPComponentsNicFactory.build();
 107
 108                 deepFreeze(expectedData);
 109
 110                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 111                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}`);
 112                         expect(data).toEqual(undefined);
 113                         expect(options).toEqual(undefined);
 114                         return (expectedData);
 115                 });
 116
 117                 return SoftwareProductComponentsNetworkActionHelper.loadNICData({softwareProductId, version, componentId, nicId}).then((data) => {
 118                         expect(data).toEqual(expectedData);
 119                 });
 120         });
 121
 122
 123         it('load NIC Questionnaire', () => {
 124
 125                 const store = storeCreator();
 126                 deepFreeze(store.getState());
 127
 128                 const qdata = VSPComponentsNetworkQDataFactory.build();
 129                 const dataMap = VSPComponentsNetworkDataMapFactory.build();
 130                 const qgenericFieldInfo = {};
 131                 const qschema = VSPQSchemaFactory.build();
 132
 133                 deepFreeze(qdata);
 134                 deepFreeze(dataMap);
 135                 deepFreeze(qschema);
 136
 137
 138                 const network = VSPComponentsNetworkFactory.build({
 139                         nicEditor: {
 140                                 qdata,
 141                                 dataMap,
 142                                 qgenericFieldInfo
 143                         }
 144                 });
 145                 deepFreeze(network);
 146
 147                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 148
 149                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 150                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}/questionnaire`);
 151                         expect(data).toEqual(undefined);
 152                         expect(options).toEqual(undefined);
 153                         return ({data: JSON.stringify(qdata), schema: JSON.stringify(qschema)});
 154                 });
 155
 156                 return SoftwareProductComponentsNetworkActionHelper.loadNICQuestionnaire(store.dispatch, {softwareProductId, version, componentId, nicId}).then(() => {
 157                         expect(store.getState()).toEqual(expectedStore);
 158                         expect(store.getState()).toEqual(expectedStore);
 159                 });
 160         });
 161
 162         it('save NIC Data And Questionnaire', () => {
 163
 164                 const store = storeCreator();
 165                 deepFreeze(store.getState());
 166
 167                 const qdata = VSPComponentsNetworkQDataFactory.build();
 168                 const data = VSPComponentsNicFactory.build();
 169
 170                 const expectedData = {...data, id: nicId};
 171
 172                 const network = {
 173                         nicEditor: {},
 174                         nicList: [
 175                                 expectedData
 176                         ]
 177                 };
 178
 179                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 180                 deepFreeze(expectedStore);
 181
 182                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 183                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}/questionnaire`);
 184                         expect(data).toEqual(qdata);
 185                         expect(options).toEqual(undefined);
 186                         return {returnCode: 'OK'};
 187                 });
 188
 189                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 190                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}`);
 191                         expect(data).toEqual(data);
 192                         expect(options).toEqual(undefined);
 193                         return {returnCode: 'OK'};
 194                 });
 195
 196                 return SoftwareProductComponentsNetworkActionHelper.saveNICDataAndQuestionnaire(store.dispatch, {softwareProductId, version, componentId, qdata, data: expectedData}).then(() => {
 197                         expect(store.getState()).toEqual(expectedStore);
 198                 });
 199         });
 200
 201
 202 });