openecomp-ui/test/softwareProduct/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 {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 SoftwareProductProcessesActionHelper from 'sdc-app/onboarding/softwareProduct/processes/SoftwareProductProcessesActionHelper.js';
  22 import {
  23         VSPProcessPostFactory,
  24         VSPProcessStoreFactory,
  25         VSPProcessPostFactoryWithType,
  26         VSPProcessStoreFactoryWithType,
  27         VSPProcessStoreWithFormDataFactory,
  28         VSPProcessPostWithFormDataFactory,
  29         VSPProcessStoreWithArtifactNameFactory } from 'test-utils/factories/softwareProduct/SoftwareProductProcessFactories.js';
  30 import {buildFromExistingObject} from 'test-utils/Util.js';
  31 import {VSPEditorFactory} from 'test-utils/factories/softwareProduct/SoftwareProductEditorFactories.js';
  32 import ValidationHelper from 'sdc-app/common/helpers/ValidationHelper.js';
  33
  34 const softwareProductId = '123';
  35 const version = VSPEditorFactory.build().version;
  36
  37 describe('Software Product Processes Module Tests', function () {
  38
  39         let restPrefix = '';
  40
  41         beforeAll(function() {
  42                 restPrefix = Configuration.get('restPrefix');
  43                 deepFreeze(restPrefix);
  44         });
  45
  46         //**
  47         //** ADD
  48         //**
  49         it('Add Software Products Processes', () => {
  50
  51                 const store = storeCreator();
  52                 deepFreeze(store.getState());
  53
  54                 const softwareProductProcessFromResponse = 'ADDED_ID';
  55
  56                 const softwareProductProcessAfterAdd = VSPProcessStoreFactory.build({id: softwareProductProcessFromResponse});
  57                 const softwareProductPostRequest = buildFromExistingObject(VSPProcessPostFactory, softwareProductProcessAfterAdd);
  58
  59                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', [softwareProductProcessAfterAdd]);
  60
  61                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
  62
  63                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes`);
  64                         expect(data).toEqual(softwareProductPostRequest);
  65                         expect(options).toEqual(undefined);
  66                         return {
  67                                 returnCode: 'OK',
  68                                 value: softwareProductProcessFromResponse
  69                         };
  70                 });
  71
  72                 return SoftwareProductProcessesActionHelper.saveProcess(store.dispatch,
  73                         {
  74                                 softwareProductId,
  75                                 version,
  76                                 previousProcess: null,
  77                                 process: softwareProductPostRequest
  78                         }
  79                 ).then(() => {
  80                         expect(store.getState()).toEqual(expectedStore);
  81                 });
  82         });
  83
  84         it('Add Software Products Processes with type', () => {
  85
  86                 const store = storeCreator();
  87                 deepFreeze(store.getState());
  88
  89                 const softwareProductProcessFromResponse = 'ADDED_ID';
  90
  91                 const softwareProductProcessAfterAdd = VSPProcessStoreFactoryWithType.build({id: softwareProductProcessFromResponse});
  92                 const softwareProductPostRequest = buildFromExistingObject(VSPProcessPostFactoryWithType, softwareProductProcessAfterAdd);
  93
  94                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', [softwareProductProcessAfterAdd]);
  95
  96                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
  97
  98                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes`);
  99                         expect(data).toEqual(softwareProductPostRequest);
 100                         expect(options).toEqual(undefined);
 101                         return {
 102                                 returnCode: 'OK',
 103                                 value: softwareProductProcessFromResponse
 104                         };
 105                 });
 106
 107                 return SoftwareProductProcessesActionHelper.saveProcess(store.dispatch,
 108                         {
 109                                 softwareProductId,
 110                                 version,
 111                                 previousProcess: null,
 112                                 process: softwareProductPostRequest
 113                         }
 114                 ).then(() => {
 115                         expect(store.getState()).toEqual(expectedStore);
 116                 });
 117         });
 118
 119         it('Add Software Products Processes with uploaded file', () => {
 120
 121                 const store = storeCreator();
 122                 deepFreeze(store.getState());
 123
 124                 const softwareProductPostRequest = VSPProcessPostFactoryWithType.build();
 125                 const softwareProductProcessToAdd = VSPProcessPostWithFormDataFactory.build(softwareProductPostRequest);
 126                 const softwareProductProcessAfterAdd = VSPProcessStoreWithFormDataFactory.build();
 127
 128                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', [softwareProductProcessAfterAdd]);
 129
 130                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 131                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes`);
 132                         expect(data).toEqual(softwareProductPostRequest);
 133                         expect(options).toEqual(undefined);
 134                         return {
 135                                 returnCode: 'OK',
 136                                 value: softwareProductProcessAfterAdd.id
 137                         };
 138                 });
 139
 140                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 141                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes/${softwareProductProcessAfterAdd.id}/upload`);
 142                         expect(data).toEqual(softwareProductProcessToAdd.formData);
 143                         expect(options).toEqual(undefined);
 144                         return {returnCode: 'OK'};
 145                 });
 146
 147                 return SoftwareProductProcessesActionHelper.saveProcess(store.dispatch,
 148                         {
 149                                 softwareProductId,
 150                                 version,
 151                                 previousProcess: null,
 152                                 process: softwareProductProcessToAdd
 153                         }
 154                 ).then(() => {
 155                         expect(store.getState()).toEqual(expectedStore);
 156                 });
 157         });
 158
 159         //**
 160         //** UPDATE
 161         //**
 162         it('Update Software Products Processes', () => {
 163                 const softwareProductProcessesList = VSPProcessStoreWithArtifactNameFactory.buildList(1);
 164                 deepFreeze(softwareProductProcessesList);
 165
 166                 const store = storeCreator({
 167                         softwareProduct: {
 168                                 softwareProductProcesses: {
 169                                         processesList: softwareProductProcessesList
 170                                 }
 171                         }
 172                 });
 173                 deepFreeze(store.getState());
 174
 175                 const toBeUpdatedProcessId = softwareProductProcessesList[0].id;
 176                 const previousProcessData = softwareProductProcessesList[0];
 177                 const processUpdateData = VSPProcessStoreWithArtifactNameFactory.build(
 178                         {...previousProcessData,
 179                                 name: 'Pr1_UPDATED',
 180                                 description: 'string_UPDATED',
 181                                 type: 'Other'
 182                         }
 183                 );
 184
 185                 deepFreeze(processUpdateData);
 186
 187                 const processPutRequest = VSPProcessPostFactory.build({
 188                         name: 'Pr1_UPDATED',
 189                         description: 'string_UPDATED',
 190                         type: 'Other'
 191                 });
 192                 deepFreeze(processPutRequest);
 193
 194                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', [processUpdateData]);
 195
 196
 197                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 198                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes/${toBeUpdatedProcessId}`);
 199                         expect(data).toEqual(processPutRequest);
 200                         expect(options).toEqual(undefined);
 201                         return {returnCode: 'OK'};
 202                 });
 203
 204                 return SoftwareProductProcessesActionHelper.saveProcess(store.dispatch,
 205                         {
 206                                 softwareProductId,
 207                                 version,
 208                                 previousProcess: previousProcessData,
 209                                 process: processUpdateData
 210                         }
 211                 ).then(() => {
 212                         expect(store.getState()).toEqual(expectedStore);
 213                 });
 214         });
 215
 216         it('Update Software Products Processes and uploaded file', () => {
 217                 const previousProcessData = VSPProcessStoreWithArtifactNameFactory.build();
 218                 deepFreeze(previousProcessData);
 219
 220                 const store = storeCreator({
 221                         softwareProduct: {
 222                                 softwareProductProcesses: {
 223                                         processesList: [previousProcessData]
 224                                 }
 225                         }
 226                 });
 227                 deepFreeze(store.getState());
 228
 229                 const newProcessToUpdate = VSPProcessStoreWithFormDataFactory.build({
 230                         ...previousProcessData,
 231                         name: 'new name',
 232                         formData: {
 233                                 name: 'new artifact name'
 234                         }
 235                 });
 236                 deepFreeze(newProcessToUpdate);
 237
 238                 const newProcessToPutRequest = VSPProcessPostFactory.build({
 239                         name: newProcessToUpdate.name,
 240                         description: previousProcessData.description,
 241                         type: previousProcessData.type
 242                 });
 243                 deepFreeze(newProcessToPutRequest);
 244
 245                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', [newProcessToUpdate]);
 246
 247                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 248                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes/${newProcessToUpdate.id}`);
 249                         expect(data).toEqual(newProcessToPutRequest);
 250                         expect(options).toEqual(undefined);
 251                         return {returnCode: 'OK'};
 252                 });
 253
 254                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 255                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes/${newProcessToUpdate.id}/upload`);
 256                         expect(data).toEqual(newProcessToUpdate.formData);
 257                         expect(options).toEqual(undefined);
 258                         return {returnCode: 'OK'};
 259                 });
 260
 261                 return SoftwareProductProcessesActionHelper.saveProcess(store.dispatch,
 262                         {
 263                                 softwareProductId,
 264                                 version,
 265                                 previousProcess: previousProcessData,
 266                                 process: newProcessToUpdate
 267                         }
 268                 ).then(() => {
 269                         expect(store.getState()).toEqual(expectedStore);
 270                 });
 271         });
 272
 273         //**
 274         //** GET
 275         //**
 276         it('Get Software Products Processes List', () => {
 277                 const store = storeCreator();
 278                 deepFreeze(store.getState());
 279
 280                 const softwareProductProcessesList = VSPProcessStoreFactory.buildList(2);
 281
 282                 deepFreeze(softwareProductProcessesList);
 283
 284                 deepFreeze(store.getState());
 285
 286                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', softwareProductProcessesList);
 287
 288                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 289                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/processes`);
 290                         expect(data).toEqual(undefined);
 291                         expect(options).toEqual(undefined);
 292                         return {results: softwareProductProcessesList};
 293                 });
 294
 295                 return SoftwareProductProcessesActionHelper.fetchProcessesList(store.dispatch, {softwareProductId, version}).then(() => {
 296                         expect(store.getState()).toEqual(expectedStore);
 297                 });
 298         });
 299
 300         //**
 301         //** DELETE
 302         //**
 303         it('Delete Software Products Processes', () => {
 304                 const softwareProductProcessesList = VSPProcessStoreWithArtifactNameFactory.buildList(1);
 305                 const currentSoftwareProduct = VSPEditorFactory.build();
 306
 307                 deepFreeze(softwareProductProcessesList);
 308                 const store = storeCreator({
 309                         softwareProduct: {
 310                                 softwareProductProcesses: {
 311                                         processesList: softwareProductProcessesList
 312                                 },
 313                                 softwareProductEditor: {
 314                                         data: currentSoftwareProduct
 315                                 }
 316                         }
 317                 });
 318
 319                 const processId = softwareProductProcessesList[0].id;
 320                 const version = store.getState().softwareProduct.softwareProductEditor.data.version;
 321                 const versionId = version.id;
 322                 deepFreeze(store.getState());
 323
 324                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesList', []);
 325
 326                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
 327                         expect(baseUrl).toEqual(`${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/processes/${processId}`);
 328                         expect(data).toEqual(undefined);
 329                         expect(options).toEqual(undefined);
 330                         return {
 331                                 results: {
 332                                         returnCode: 'OK'
 333                                 }
 334                         };
 335                 });
 336
 337                 return SoftwareProductProcessesActionHelper.deleteProcess(store.dispatch, {
 338                         process: softwareProductProcessesList[0],
 339                         softwareProductId,
 340                         version
 341                 }).then(() => {
 342                         expect(store.getState()).toEqual(expectedStore);
 343                 });
 344         });
 345
 346         it('Validating Software Products Processes Delete confirmation', done => {
 347                 const store = storeCreator();
 348                 deepFreeze(store.getState());
 349
 350                 let process = VSPProcessStoreFactory.build();
 351                 deepFreeze(process);
 352
 353                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processToDelete', process);
 354
 355                 SoftwareProductProcessesActionHelper.openDeleteProcessesConfirm(store.dispatch, {process});
 356
 357                 setTimeout(function(){
 358                         expect(store.getState()).toEqual(expectedStore);
 359                         done();
 360                 }, 100);
 361         });
 362
 363         it('Validating Software Products Processes Cancel Delete', done => {
 364                 const store = storeCreator();
 365                 deepFreeze(store.getState());
 366
 367                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processToDelete', false);
 368
 369                 SoftwareProductProcessesActionHelper.hideDeleteConfirm(store.dispatch);
 370
 371                 setTimeout(function(){
 372                         expect(store.getState()).toEqual(expectedStore);
 373                         done();
 374                 }, 100);
 375         });
 376
 377         //**
 378         //** CREATE/EDIT
 379         //**
 380         it('Validating open Software Products Processes for create', () => {
 381                 const store = storeCreator();
 382                 deepFreeze(store.getState());
 383
 384                 let process = {};
 385                 deepFreeze(process);
 386
 387                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesEditor.data', process);
 388
 389                 SoftwareProductProcessesActionHelper.openEditor(store.dispatch);
 390                 expect(store.getState().softwareProduct.softwareProductProcesses.processesEditor.data).toEqual(expectedStore.softwareProduct.softwareProductProcesses.processesEditor.data);
 391         });
 392
 393         it('Validating close Software Products Processes from editing mode', () => {
 394                 const store = storeCreator();
 395                 deepFreeze(store.getState());
 396
 397                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesEditor', {});
 398
 399                 SoftwareProductProcessesActionHelper.closeEditor(store.dispatch);
 400                 expect(store.getState()).toEqual(expectedStore);
 401         });
 402
 403         it('Validating open Software Products Processes for editing', () => {
 404                 const store = storeCreator();
 405                 deepFreeze(store.getState());
 406
 407                 let process = {name: 'aa', description: 'xx'};
 408                 deepFreeze(process);
 409
 410                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductProcesses.processesEditor.data', process);
 411
 412                 SoftwareProductProcessesActionHelper.openEditor(store.dispatch, process);
 413                 expect(store.getState().softwareProduct.softwareProductProcesses.processesEditor.data).toEqual(expectedStore.softwareProduct.softwareProductProcesses.processesEditor.data);
 414
 415         });
 416
 417 });