openecomp-ui/test/softwareProduct/components/compute/VSPComponentComputeActionHelperManualMode.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 Configuration from 'sdc-app/config/Configuration.js';
  21 import ComputeFlavorActionHelper from 'sdc-app/onboarding/softwareProduct/components/compute/ComputeFlavorActionHelper.js';
  22 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  23
  24 import {ComputeFlavorQData, ComputeFlavorBaseData, ComponentComputeFactory, VSPComponentsComputeDataMapFactory} from 'test-utils/factories/softwareProduct/SoftwareProductComponentsComputeFactory.js';
  25
  26 const softwareProductId = '123';
  27 const vspComponentId = '111';
  28 const computeId = '111';
  29 const version = VersionFactory.build();
  30
  31
  32 describe('Software Product Components Compute Module Tests - Manual mode', function () {
  33
  34         let restPrefix = '';
  35
  36         beforeAll(function() {
  37                 restPrefix = Configuration.get('restPrefix');
  38                 deepFreeze(restPrefix);
  39         });
  40
  41
  42         it('Close Compute Flavor editor', () => {
  43
  44                 const store = storeCreator();
  45                 deepFreeze(store.getState());
  46
  47                 const compute = ComponentComputeFactory.build();
  48                 deepFreeze(compute);
  49
  50                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor', compute);
  51
  52                 ComputeFlavorActionHelper.closeComputeEditor(store.dispatch);
  53                 expect(store.getState()).toEqual(expectedStore);
  54         });
  55
  56         it('Get Computes List', () => {
  57                 const store = storeCreator();
  58                 deepFreeze(store.getState());
  59
  60                 const computesList = ComputeFlavorBaseData.buildList(2);
  61                 deepFreeze(computesList);
  62
  63                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor.computesList', computesList);
  64
  65                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  66                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors`);
  67                         expect(data).toEqual(undefined);
  68                         expect(options).toEqual(undefined);
  69                         return {results: computesList};
  70                 });
  71
  72                 return ComputeFlavorActionHelper.fetchComputesList(store.dispatch, {softwareProductId, componentId: vspComponentId, version}).then(() => {
  73                         expect(store.getState()).toEqual(expectedStore);
  74                 });
  75         });
  76
  77         it('Load Compute data & Questionnaire', () => {
  78                 const store = storeCreator();
  79                 deepFreeze(store.getState());
  80
  81                 const computeData = {
  82                         ...ComputeFlavorBaseData.build(),
  83                         id: computeId
  84                 };
  85                 deepFreeze(computeData);
  86                 const qdata = ComputeFlavorQData.build();
  87                 const dataMap = VSPComponentsComputeDataMapFactory.build();
  88
  89                 const softwareProductComponentCompute = {
  90                         data: JSON.stringify(qdata),
  91                         schema: JSON.stringify(qdata)
  92                 };
  93                 deepFreeze(softwareProductComponentCompute);
  94
  95                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  96                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}`);
  97                         expect(data).toEqual(undefined);
  98                         expect(options).toEqual(undefined);
  99                         return {data: computeData};
 100                 });
 101                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 102                         expect(baseUrl).toEqual(
 103                                 `/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}/questionnaire`
 104                         );
 105                         expect(data).toEqual(undefined);
 106                         expect(options).toEqual(undefined);
 107                         return softwareProductComponentCompute;
 108                 });
 109
 110                 return ComputeFlavorActionHelper.loadCompute(store.dispatch, {softwareProductId, componentId: vspComponentId, version, computeId}).then(() => {
 111                         expect(store.getState().softwareProduct.softwareProductComponents.computeFlavor.computeEditor.data).toEqual(computeData);
 112                         expect(store.getState().softwareProduct.softwareProductComponents.computeFlavor.computeEditor.qdata).toEqual(qdata);
 113                         expect(store.getState().softwareProduct.softwareProductComponents.computeFlavor.computeEditor.dataMap).toEqual(dataMap);
 114                 });
 115         });
 116
 117         it('Save Compute Flavor data and questionnaire', () => {
 118
 119                 const store = storeCreator();
 120                 deepFreeze(store.getState());
 121
 122                 const qdata = ComputeFlavorQData.build();
 123                 const data = ComputeFlavorBaseData.build();
 124
 125                 const compute = {...data, id: computeId};
 126
 127                 const computeObj = {
 128                         computeEditor: {},
 129                         computesList: [
 130                                 compute
 131                         ]
 132                 };
 133
 134                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor', computeObj);
 135                 deepFreeze(expectedStore);
 136
 137                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 138                         expect(baseUrl).toEqual(
 139                                 `/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}/questionnaire`
 140                         );
 141                         expect(data).toEqual(qdata);
 142                         expect(options).toEqual(undefined);
 143                         return {returnCode: 'OK'};
 144                 });
 145
 146                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 147                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}`);
 148                         expect(data).toEqual(data);
 149                         expect(options).toEqual(undefined);
 150                         return {returnCode: 'OK'};
 151                 });
 152
 153                 return ComputeFlavorActionHelper.saveComputeDataAndQuestionnaire(store.dispatch, {softwareProductId, componentId: vspComponentId, qdata, data: compute, version}).then(() => {
 154                         expect(store.getState()).toEqual(expectedStore);
 155                 });
 156         });
 157
 158         it('Delete Compute Flavor', () => {
 159                 const compute = ComponentComputeFactory.build();
 160                 const computesList = [compute];
 161                 deepFreeze(computesList);
 162
 163                 const store = storeCreator({
 164                         softwareProduct: {
 165                                 softwareProductComponents: {
 166                                         computeFlavor: {
 167                                                 computesList: computesList
 168                                         }
 169                                 }
 170                         }
 171                 });
 172                 deepFreeze(store.getState());
 173
 174                 const computeId = compute.id;
 175
 176                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor.computesList', []);
 177
 178                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
 179                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}`);
 180                         expect(data).toEqual(undefined);
 181                         expect(options).toEqual(undefined);
 182                         return {
 183                                 results: {
 184                                         returnCode: 'OK'
 185                                 }
 186                         };
 187                 });
 188
 189                 return ComputeFlavorActionHelper.deleteCompute(store.dispatch, {softwareProductId, componentId: vspComponentId, computeId, version}).then(() => {
 190                         expect(store.getState()).toEqual(expectedStore);
 191                 });
 192         });
 193 });