gerrit.onap Code Review - sdc.git/blob

   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 {VSPEditorFactory} from 'test-utils/factories/softwareProduct/SoftwareProductEditorFactories.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 = VSPEditorFactory.build().version;
  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
  96                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor.computeEditor', {
  97                         data: computeData,
  98                         qdata,
  99                         dataMap,
 100                         qgenericFieldInfo: {},
 101                         genericFieldInfo: {},
 102                         formReady: true
 103                 });
 104
 105                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 106                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}`);
 107                         expect(data).toEqual(undefined);
 108                         expect(options).toEqual(undefined);
 109                         return {data: computeData};
 110                 });
 111                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 112                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}/questionnaire`);
 113                         expect(data).toEqual(undefined);
 114                         expect(options).toEqual(undefined);
 115                         return softwareProductComponentCompute;
 116                 });
 117
 118                 return ComputeFlavorActionHelper.loadComputeData({softwareProductId, componentId: vspComponentId, version, computeId}).then(() => {
 119                         ComputeFlavorActionHelper.loadComputeQuestionnaire(store.dispatch, {softwareProductId, componentId: vspComponentId, computeId, version}).then(() =>
 120                                 expect(store.getState()).toEqual(expectedStore));
 121                 });
 122         });
 123
 124         it('Save Compute Flavor data and questionnaire', () => {
 125
 126                 const store = storeCreator();
 127                 deepFreeze(store.getState());
 128
 129                 const qdata = ComputeFlavorQData.build();
 130                 const data = ComputeFlavorBaseData.build();
 131
 132                 const compute = {...data, id: computeId};
 133
 134                 const computeObj = {
 135                         computeEditor: {},
 136                         computesList: [
 137                                 compute
 138                         ]
 139                 };
 140
 141                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor', computeObj);
 142                 deepFreeze(expectedStore);
 143
 144                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 145                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}/questionnaire`);
 146                         expect(data).toEqual(qdata);
 147                         expect(options).toEqual(undefined);
 148                         return {returnCode: 'OK'};
 149                 });
 150
 151                 mockRest.addHandler('put', ({options, data, baseUrl}) => {
 152                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}`);
 153                         expect(data).toEqual(data);
 154                         expect(options).toEqual(undefined);
 155                         return {returnCode: 'OK'};
 156                 });
 157
 158                 return ComputeFlavorActionHelper.saveComputeDataAndQuestionnaire(store.dispatch, {softwareProductId, componentId: vspComponentId, qdata, data: compute, version}).then(() => {
 159                         expect(store.getState()).toEqual(expectedStore);
 160                 });
 161         });
 162
 163         it('Delete Compute Flavor', () => {
 164                 const compute = ComponentComputeFactory.build();
 165                 const computesList = [compute];
 166                 deepFreeze(computesList);
 167
 168                 const store = storeCreator({
 169                         softwareProduct: {
 170                                 softwareProductComponents: {
 171                                         computeFlavor: {
 172                                                 computesList: computesList
 173                                         }
 174                                 }
 175                         }
 176                 });
 177                 deepFreeze(store.getState());
 178
 179                 const computeId = compute.id;
 180
 181                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.computeFlavor.computesList', []);
 182
 183                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
 184                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${vspComponentId}/compute-flavors/${computeId}`);
 185                         expect(data).toEqual(undefined);
 186                         expect(options).toEqual(undefined);
 187                         return {
 188                                 results: {
 189                                         returnCode: 'OK'
 190                                 }
 191                         };
 192                 });
 193
 194                 return ComputeFlavorActionHelper.deleteCompute(store.dispatch, {softwareProductId, componentId: vspComponentId, computeId, version}).then(() => {
 195                         expect(store.getState()).toEqual(expectedStore);
 196                 });
 197         });
 198 });