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