openecomp-ui/test/softwareProduct/components/processes/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 {buildFromExistingObject} from 'test-utils/Util.js';
  19 import {cloneAndSet} from 'test-utils/Util.js';
  20 import {storeCreator} from 'sdc-app/AppStore.js';
  21 import SoftwareProductComponentProcessesActionHelper from 'sdc-app/onboarding/softwareProduct/components/processes/SoftwareProductComponentProcessesActionHelper.js';
  22
  23 import {
  24         VSPProcessStoreWithArtifactNameFactory,
  25         VSPProcessPostFactory,
  26         VSPProcessStoreFactory,
  27         VSPProcessPostFactoryWithType,
  28         VSPProcessStoreFactoryWithType} from 'test-utils/factories/softwareProduct/SoftwareProductProcessFactories.js';
  29
  30 const softwareProductId = '123';
  31 const componentId = '222';
  32 const versionId = '1';
  33 const version = {id: versionId, label: versionId};
  34
  35 describe('Software Product Component Processes Module Tests', function () {
  36         it('Get Software Products Processes List', () => {
  37                 const store = storeCreator();
  38                 deepFreeze(store.getState());
  39
  40                 const softwareProductProcessesList = VSPProcessStoreWithArtifactNameFactory.buildList(2);
  41
  42                 deepFreeze(softwareProductProcessesList);
  43
  44                 deepFreeze(store.getState());
  45
  46                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.componentProcesses.processesList', softwareProductProcessesList);
  47
  48                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  49                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/components/${componentId}/processes`);
  50                         expect(data).toEqual(undefined);
  51                         expect(options).toEqual(undefined);
  52                         return {results: softwareProductProcessesList};
  53                 });
  54
  55
  56                 return SoftwareProductComponentProcessesActionHelper.fetchProcessesList(store.dispatch, {softwareProductId, componentId, version}).then(() => {
  57                         expect(store.getState()).toEqual(expectedStore);
  58                 });
  59         });
  60         it('Delete Software Products Processes', () => {
  61                 let process = VSPProcessStoreWithArtifactNameFactory.build();
  62                 const softwareProductProcessesList = [process];
  63
  64                 deepFreeze(softwareProductProcessesList);
  65                 const store = storeCreator({
  66                         softwareProduct: {
  67                                 softwareProductProcesses: {
  68                                         processesList: softwareProductProcessesList
  69                                 }
  70                         }
  71                 });
  72
  73                 const processId = process.id;
  74                 deepFreeze(store.getState());
  75
  76                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.componentProcesses.processesList', []);
  77
  78                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
  79                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/components/${componentId}/processes/${processId}`);
  80                         expect(data).toEqual(undefined);
  81                         expect(options).toEqual(undefined);
  82                         return {
  83                                 results: {
  84                                         returnCode: 'OK'
  85                                 }
  86                         };
  87                 });
  88
  89                 return SoftwareProductComponentProcessesActionHelper.deleteProcess(store.dispatch, {
  90                         process: softwareProductProcessesList[0],
  91                         softwareProductId, componentId,
  92                         version
  93                 }).then(() => {
  94                         expect(store.getState()).toEqual(expectedStore);
  95                 });
  96         });
  97
  98         it('Add Software Products Processes', () => {
  99
 100                 const store = storeCreator();
 101                 deepFreeze(store.getState());
 102
 103                 const softwareProductProcessFromResponse = 'ADDED_ID';
 104
 105                 const softwareProductProcessAfterAdd = VSPProcessStoreFactory.build({id: softwareProductProcessFromResponse});
 106                 const softwareProductPostRequest = buildFromExistingObject(VSPProcessPostFactory, softwareProductProcessAfterAdd);
 107
 108                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.componentProcesses.processesList', [softwareProductProcessAfterAdd]);
 109
 110                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 111
 112                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/components/${componentId}/processes`);
 113                         expect(data).toEqual(softwareProductPostRequest);
 114                         expect(options).toEqual(undefined);
 115                         return {
 116                                 returnCode: 'OK',
 117                                 value: softwareProductProcessFromResponse
 118                         };
 119                 });
 120
 121                 return SoftwareProductComponentProcessesActionHelper.saveProcess(store.dispatch,
 122                         {
 123                                 softwareProductId,
 124                                 previousProcess: null,
 125                                 process: softwareProductPostRequest,
 126                                 componentId,
 127                                 version
 128                         }
 129                 ).then(() => {
 130                         expect(store.getState()).toEqual(expectedStore);
 131                 });
 132         });
 133
 134         it('Add Software Products Processes with type', () => {
 135
 136                 const store = storeCreator();
 137                 deepFreeze(store.getState());
 138
 139                 const softwareProductPostRequest = VSPProcessPostFactoryWithType.build();
 140
 141                 const softwareProductProcessAfterAdd = VSPProcessStoreFactoryWithType.build(softwareProductPostRequest);
 142                 const softwareProductProcessFromResponse = softwareProductProcessAfterAdd.id;
 143
 144                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.componentProcesses.processesList', [softwareProductProcessAfterAdd]);
 145
 146                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 147
 148                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/components/${componentId}/processes`);
 149                         expect(data).toEqual(softwareProductPostRequest);
 150                         expect(options).toEqual(undefined);
 151                         return {
 152                                 returnCode: 'OK',
 153                                 value: softwareProductProcessFromResponse
 154                         };
 155                 });
 156
 157                 return SoftwareProductComponentProcessesActionHelper.saveProcess(store.dispatch,
 158                         {
 159                                 softwareProductId,
 160                                 previousProcess: null,
 161                                 process: softwareProductPostRequest,
 162                                 componentId,
 163                                 version
 164                         }
 165                 ).then(() => {
 166                         expect(store.getState()).toEqual(expectedStore);
 167                 });
 168         });
 169
 170         it('Update Software Products Processes', () => {
 171                 let process = VSPProcessStoreWithArtifactNameFactory.build();
 172
 173                 const softwareProductProcessesList = [process];
 174                 deepFreeze(softwareProductProcessesList);
 175
 176                 const store = storeCreator({
 177                         softwareProduct: {
 178                                 softwareProductComponents: {
 179                                         componentProcesses: {
 180                                                 processesList: softwareProductProcessesList
 181                                         }
 182                                 }
 183                         }
 184                 });
 185                 deepFreeze(store.getState());
 186
 187                 const toBeUpdatedProcessId = process.id;
 188                 const previousProcessData = process;
 189                 const processUpdateData = VSPProcessStoreWithArtifactNameFactory.build({
 190                         ...process,
 191                         name: 'Pr1_UPDATED',
 192                         description: 'string_UPDATED',
 193                         type: 'Other'
 194                 });
 195                 deepFreeze(processUpdateData);
 196
 197                 const processPutRequest = VSPProcessPostFactory.build({
 198                         name: 'Pr1_UPDATED',
 199                         description: 'string_UPDATED',
 200                         type: 'Other'
 201                 });
 202                 deepFreeze(processPutRequest);
 203
 204                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductComponents.componentProcesses.processesList', [processUpdateData]);
 205
 206
 207                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 208                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/components/${componentId}/processes/${toBeUpdatedProcessId}`);
 209                         expect(data).toEqual(processPutRequest);
 210                         expect(options).toEqual(undefined);
 211                         return {returnCode: 'OK'};
 212                 });
 213
 214                 return SoftwareProductComponentProcessesActionHelper.saveProcess(store.dispatch,
 215                         {
 216                                 softwareProductId: softwareProductId,
 217                                 componentId,
 218                                 previousProcess: previousProcessData,
 219                                 process: processUpdateData,
 220                                 version
 221                         }
 222                 ).then(() => {
 223                         expect(store.getState()).toEqual(expectedStore);
 224                 });
 225         });
 226
 227 });