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 {VSPComponentsNicPostFactory, 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         it('Add NIC', () => {
  59                         const store = storeCreator();
  60                         deepFreeze(store.getState());
  61
  62                         const NICPostRequest = VSPComponentsNicPostFactory.build();
  63
  64                         const expectedNIC = VSPComponentsNicFactory.build({...NICPostRequest, id: nicId});
  65
  66                         mockRest.addHandler('post', ({options, data, baseUrl}) => {
  67                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics`);
  68                                 expect(data).toEqual(NICPostRequest);
  69                                 expect(options).toEqual(undefined);
  70                                 return {
  71                                         nicId
  72                                 };
  73                         });
  74
  75                         mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  76                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics`);
  77                                 expect(data).toEqual(undefined);
  78                                 expect(options).toEqual(undefined);
  79                                 return {results: [expectedNIC]};
  80                         });
  81
  82                         mockRest.addHandler('destroy', ({options, data, baseUrl}) => {
  83                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}`);
  84                                 expect(data).toEqual(undefined);
  85                                 expect(options).toEqual(undefined);
  86                                 return {};
  87                         });
  88
  89                         mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  90                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics`);
  91                                 expect(data).toEqual(undefined);
  92                                 expect(options).toEqual(undefined);
  93                                 return {results: []};
  94                         });
  95
  96                         const network = VSPComponentsNetworkFactory.build({
  97                                 nicList: [expectedNIC]
  98                         });
  99
 100                         const networkAfterDelete = VSPComponentsNetworkFactory.build();
 101
 102                         let expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 103
 104                         return SoftwareProductComponentsNetworkActionHelper.createNIC(store.dispatch, {nic: NICPostRequest, softwareProductId, componentId, version}).then(() => {
 105                                 expect(store.getState()).toEqual(expectedStore);
 106                                 return SoftwareProductComponentsNetworkActionHelper.deleteNIC(store.dispatch, {softwareProductId, componentId, nicId, version});
 107                         }).then(() => {
 108                                 let expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', networkAfterDelete);
 109                                 expect(store.getState()).toEqual(expectedStore);
 110                         });
 111                 });
 112         it('open NICE editor', () => {
 113
 114                 const store = storeCreator();
 115                 deepFreeze(store.getState());
 116                 const data = VSPComponentsNicFactory.build();
 117                 const genericFieldInfo = VSPComponentsNicFactoryGenericFieldInfo.build();
 118
 119                 const nic = {id: '444'};
 120                 deepFreeze(data);
 121                 deepFreeze(nic);
 122
 123                 const expectedData = {...data, id: nic.id};
 124
 125                 deepFreeze(expectedData);
 126
 127                 const network = VSPComponentsNetworkFactory.build({
 128                         nicEditor: {
 129                                 data: expectedData,
 130                                 formName: forms.NIC_EDIT_FORM,
 131                                 genericFieldInfo
 132                         }
 133                 });
 134
 135                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 136
 137                 SoftwareProductComponentsNetworkActionHelper.openNICEditor(store.dispatch, {nic, data});
 138
 139                 expect(store.getState().softwareProduct.softwareProductComponents.network).toEqual(expectedStore.softwareProduct.softwareProductComponents.network);
 140         });
 141
 142         it('close NICE editor', () => {
 143
 144                 const store = storeCreator();
 145                 deepFreeze(store.getState());
 146
 147                 const network = VSPComponentsNetworkFactory.build();
 148                 deepFreeze(network);
 149
 150                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 151
 152                 SoftwareProductComponentsNetworkActionHelper.closeNICEditor(store.dispatch);
 153
 154                 expect(store.getState()).toEqual(expectedStore);
 155         });
 156
 157         it('Load NIC data', () => {
 158                 mockRest.resetQueue();
 159                 const expectedData = VSPComponentsNicFactory.build();
 160
 161                 deepFreeze(expectedData);
 162
 163                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 164                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}`);
 165                         expect(data).toEqual(undefined);
 166                         expect(options).toEqual(undefined);
 167                         return (expectedData);
 168                 });
 169
 170                 return SoftwareProductComponentsNetworkActionHelper.loadNICData({softwareProductId, version, componentId, nicId}).then((data) => {
 171                         expect(data).toEqual(expectedData);
 172                 });
 173         });
 174
 175
 176         it('load NIC Questionnaire', () => {
 177                 mockRest.resetQueue();
 178                 const store = storeCreator();
 179                 deepFreeze(store.getState());
 180
 181                 const qdata = VSPComponentsNetworkQDataFactory.build();
 182                 const dataMap = VSPComponentsNetworkDataMapFactory.build();
 183                 const qgenericFieldInfo = {};
 184                 const qschema = VSPQSchemaFactory.build();
 185
 186                 deepFreeze(qdata);
 187                 deepFreeze(dataMap);
 188                 deepFreeze(qschema);
 189
 190
 191                 const network = VSPComponentsNetworkFactory.build({
 192                         nicEditor: {
 193                                 qdata,
 194                                 dataMap,
 195                                 qgenericFieldInfo
 196                         }
 197                 });
 198                 deepFreeze(network);
 199
 200                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 201
 202                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 203                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}/questionnaire`);
 204                         expect(data).toEqual(undefined);
 205                         expect(options).toEqual(undefined);
 206                         return ({data: JSON.stringify(qdata), schema: JSON.stringify(qschema)});
 207                 });
 208
 209                 return SoftwareProductComponentsNetworkActionHelper.loadNICQuestionnaire(store.dispatch, {softwareProductId, version, componentId, nicId}).then(() => {
 210                         expect(store.getState()).toEqual(expectedStore);
 211                         expect(store.getState()).toEqual(expectedStore);
 212                 });
 213         });
 214
 215         it('save NIC Data And Questionnaire', () => {
 216
 217                 const store = storeCreator();
 218                 deepFreeze(store.getState());
 219
 220                 const qdata = VSPComponentsNetworkQDataFactory.build();
 221                 const data = VSPComponentsNicFactory.build();
 222
 223                 const expectedData = {...data, id: nicId};
 224
 225                 const network = {
 226                         nicEditor: {},
 227                         nicCreation: {},
 228                         nicList: [
 229                                 expectedData
 230                         ]
 231                 };
 232
 233                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.network', network);
 234                 deepFreeze(expectedStore);
 235
 236                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 237                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}/questionnaire`);
 238                         expect(data).toEqual(qdata);
 239                         expect(options).toEqual(undefined);
 240                         return {returnCode: 'OK'};
 241                 });
 242
 243                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 244                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/nics/${nicId}`);
 245                         expect(data).toEqual(data);
 246                         expect(options).toEqual(undefined);
 247                         return {returnCode: 'OK'};
 248                 });
 249
 250                 return SoftwareProductComponentsNetworkActionHelper.saveNICDataAndQuestionnaire(store.dispatch, {softwareProductId, version, componentId, qdata, data: expectedData}).then(() => {
 251                         expect(store.getState()).toEqual(expectedStore);
 252                 });
 253         });
 254
 255
 256 });