openecomp-ui/test/softwareProduct/processes/test.js

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   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 or implied.
  13  * See the License for the specific language governing permissions and
  14  * 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
  30 } from 'test-utils/factories/softwareProduct/SoftwareProductProcessFactories.js';
  31 import { buildFromExistingObject } from 'test-utils/Util.js';
  32 import { VSPEditorFactory } from 'test-utils/factories/softwareProduct/SoftwareProductEditorFactories.js';
  33 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  34
  35 const softwareProductId = '123';
  36 const version = VersionFactory.build();
  37
  38 describe('Software Product Processes Module Tests', function() {
  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         const store = storeCreator();
  51         deepFreeze(store.getState());
  52
  53         const softwareProductProcessFromResponse = 'ADDED_ID';
  54
  55         const softwareProductProcessAfterAdd = VSPProcessStoreFactory.build({
  56             id: softwareProductProcessFromResponse
  57         });
  58         const softwareProductPostRequest = buildFromExistingObject(
  59             VSPProcessPostFactory,
  60             softwareProductProcessAfterAdd
  61         );
  62
  63         const expectedStore = cloneAndSet(
  64             store.getState(),
  65             'softwareProduct.softwareProductProcesses.processesList',
  66             [softwareProductProcessAfterAdd]
  67         );
  68
  69         mockRest.addHandler('post', ({ data, options, baseUrl }) => {
  70             expect(baseUrl).toEqual(
  71                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
  72                     version.id
  73                 }/processes`
  74             );
  75             expect(data).toEqual(softwareProductPostRequest);
  76             expect(options).toEqual(undefined);
  77             return {
  78                 returnCode: 'OK',
  79                 value: softwareProductProcessFromResponse
  80             };
  81         });
  82
  83         return SoftwareProductProcessesActionHelper.saveProcess(
  84             store.dispatch,
  85             {
  86                 softwareProductId,
  87                 version,
  88                 previousProcess: null,
  89                 process: softwareProductPostRequest
  90             }
  91         ).then(() => {
  92             expect(store.getState()).toEqual(expectedStore);
  93         });
  94     });
  95
  96     it('Add Software Products Processes with type', () => {
  97         const store = storeCreator();
  98         deepFreeze(store.getState());
  99
 100         const softwareProductProcessFromResponse = 'ADDED_ID';
 101
 102         const softwareProductProcessAfterAdd = VSPProcessStoreFactoryWithType.build(
 103             { id: softwareProductProcessFromResponse }
 104         );
 105         const softwareProductPostRequest = buildFromExistingObject(
 106             VSPProcessPostFactoryWithType,
 107             softwareProductProcessAfterAdd
 108         );
 109
 110         const expectedStore = cloneAndSet(
 111             store.getState(),
 112             'softwareProduct.softwareProductProcesses.processesList',
 113             [softwareProductProcessAfterAdd]
 114         );
 115
 116         mockRest.addHandler('post', ({ data, options, baseUrl }) => {
 117             expect(baseUrl).toEqual(
 118                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 119                     version.id
 120                 }/processes`
 121             );
 122             expect(data).toEqual(softwareProductPostRequest);
 123             expect(options).toEqual(undefined);
 124             return {
 125                 returnCode: 'OK',
 126                 value: softwareProductProcessFromResponse
 127             };
 128         });
 129
 130         return SoftwareProductProcessesActionHelper.saveProcess(
 131             store.dispatch,
 132             {
 133                 softwareProductId,
 134                 version,
 135                 previousProcess: null,
 136                 process: softwareProductPostRequest
 137             }
 138         ).then(() => {
 139             expect(store.getState()).toEqual(expectedStore);
 140         });
 141     });
 142
 143     it('Add Software Products Processes with uploaded file', () => {
 144         const store = storeCreator();
 145         deepFreeze(store.getState());
 146
 147         const softwareProductPostRequest = VSPProcessPostFactoryWithType.build();
 148         const softwareProductProcessToAdd = VSPProcessPostWithFormDataFactory.build(
 149             softwareProductPostRequest
 150         );
 151         const softwareProductProcessAfterAdd = VSPProcessStoreWithFormDataFactory.build();
 152
 153         const expectedStore = cloneAndSet(
 154             store.getState(),
 155             'softwareProduct.softwareProductProcesses.processesList',
 156             [softwareProductProcessAfterAdd]
 157         );
 158
 159         mockRest.addHandler('post', ({ data, options, baseUrl }) => {
 160             expect(baseUrl).toEqual(
 161                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 162                     version.id
 163                 }/processes`
 164             );
 165             expect(data).toEqual(softwareProductPostRequest);
 166             expect(options).toEqual(undefined);
 167             return {
 168                 returnCode: 'OK',
 169                 value: softwareProductProcessAfterAdd.id
 170             };
 171         });
 172
 173         mockRest.addHandler('post', ({ data, options, baseUrl }) => {
 174             expect(baseUrl).toEqual(
 175                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 176                     version.id
 177                 }/processes/${softwareProductProcessAfterAdd.id}/upload`
 178             );
 179             expect(data).toEqual(softwareProductProcessToAdd.formData);
 180             expect(options).toEqual(undefined);
 181             return { returnCode: 'OK' };
 182         });
 183
 184         return SoftwareProductProcessesActionHelper.saveProcess(
 185             store.dispatch,
 186             {
 187                 softwareProductId,
 188                 version,
 189                 previousProcess: null,
 190                 process: softwareProductProcessToAdd
 191             }
 192         ).then(() => {
 193             expect(store.getState()).toEqual(expectedStore);
 194         });
 195     });
 196
 197     //**
 198     //** UPDATE
 199     //**
 200     it('Update Software Products Processes', () => {
 201         const softwareProductProcessesList = VSPProcessStoreWithArtifactNameFactory.buildList(
 202             1
 203         );
 204         deepFreeze(softwareProductProcessesList);
 205
 206         const store = storeCreator({
 207             softwareProduct: {
 208                 softwareProductProcesses: {
 209                     processesList: softwareProductProcessesList
 210                 }
 211             }
 212         });
 213         deepFreeze(store.getState());
 214
 215         const toBeUpdatedProcessId = softwareProductProcessesList[0].id;
 216         const previousProcessData = softwareProductProcessesList[0];
 217         const processUpdateData = VSPProcessStoreWithArtifactNameFactory.build({
 218             ...previousProcessData,
 219             name: 'Pr1_UPDATED',
 220             description: 'string_UPDATED',
 221             type: 'Other'
 222         });
 223
 224         deepFreeze(processUpdateData);
 225
 226         const processPutRequest = VSPProcessPostFactory.build({
 227             name: 'Pr1_UPDATED',
 228             description: 'string_UPDATED',
 229             type: 'Other'
 230         });
 231         deepFreeze(processPutRequest);
 232
 233         const expectedStore = cloneAndSet(
 234             store.getState(),
 235             'softwareProduct.softwareProductProcesses.processesList',
 236             [processUpdateData]
 237         );
 238
 239         mockRest.addHandler('put', ({ data, options, baseUrl }) => {
 240             expect(baseUrl).toEqual(
 241                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 242                     version.id
 243                 }/processes/${toBeUpdatedProcessId}`
 244             );
 245             expect(data).toEqual(processPutRequest);
 246             expect(options).toEqual(undefined);
 247             return { returnCode: 'OK' };
 248         });
 249
 250         return SoftwareProductProcessesActionHelper.saveProcess(
 251             store.dispatch,
 252             {
 253                 softwareProductId,
 254                 version,
 255                 previousProcess: previousProcessData,
 256                 process: processUpdateData
 257             }
 258         ).then(() => {
 259             expect(store.getState()).toEqual(expectedStore);
 260         });
 261     });
 262
 263     it('Update Software Products Processes and uploaded file', () => {
 264         const previousProcessData = VSPProcessStoreWithArtifactNameFactory.build();
 265         deepFreeze(previousProcessData);
 266
 267         const store = storeCreator({
 268             softwareProduct: {
 269                 softwareProductProcesses: {
 270                     processesList: [previousProcessData]
 271                 }
 272             }
 273         });
 274         deepFreeze(store.getState());
 275
 276         const newProcessToUpdate = VSPProcessStoreWithFormDataFactory.build({
 277             ...previousProcessData,
 278             name: 'new name',
 279             formData: {
 280                 name: 'new artifact name'
 281             }
 282         });
 283         deepFreeze(newProcessToUpdate);
 284
 285         const newProcessToPutRequest = VSPProcessPostFactory.build({
 286             name: newProcessToUpdate.name,
 287             description: previousProcessData.description,
 288             type: previousProcessData.type
 289         });
 290         deepFreeze(newProcessToPutRequest);
 291
 292         const expectedStore = cloneAndSet(
 293             store.getState(),
 294             'softwareProduct.softwareProductProcesses.processesList',
 295             [newProcessToUpdate]
 296         );
 297
 298         mockRest.addHandler('put', ({ data, options, baseUrl }) => {
 299             expect(baseUrl).toEqual(
 300                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 301                     version.id
 302                 }/processes/${newProcessToUpdate.id}`
 303             );
 304             expect(data).toEqual(newProcessToPutRequest);
 305             expect(options).toEqual(undefined);
 306             return { returnCode: 'OK' };
 307         });
 308
 309         mockRest.addHandler('post', ({ data, options, baseUrl }) => {
 310             expect(baseUrl).toEqual(
 311                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 312                     version.id
 313                 }/processes/${newProcessToUpdate.id}/upload`
 314             );
 315             expect(data).toEqual(newProcessToUpdate.formData);
 316             expect(options).toEqual(undefined);
 317             return { returnCode: 'OK' };
 318         });
 319
 320         return SoftwareProductProcessesActionHelper.saveProcess(
 321             store.dispatch,
 322             {
 323                 softwareProductId,
 324                 version,
 325                 previousProcess: previousProcessData,
 326                 process: newProcessToUpdate
 327             }
 328         ).then(() => {
 329             expect(store.getState()).toEqual(expectedStore);
 330         });
 331     });
 332
 333     //**
 334     //** GET
 335     //**
 336     it('Get Software Products Processes List', () => {
 337         const store = storeCreator();
 338         deepFreeze(store.getState());
 339
 340         const softwareProductProcessesList = VSPProcessStoreFactory.buildList(
 341             2
 342         );
 343
 344         deepFreeze(softwareProductProcessesList);
 345
 346         deepFreeze(store.getState());
 347
 348         const expectedStore = cloneAndSet(
 349             store.getState(),
 350             'softwareProduct.softwareProductProcesses.processesList',
 351             softwareProductProcessesList
 352         );
 353
 354         mockRest.addHandler('fetch', ({ options, data, baseUrl }) => {
 355             expect(baseUrl).toEqual(
 356                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${
 357                     version.id
 358                 }/processes`
 359             );
 360             expect(data).toEqual(undefined);
 361             expect(options).toEqual(undefined);
 362             return { results: softwareProductProcessesList };
 363         });
 364
 365         return SoftwareProductProcessesActionHelper.fetchProcessesList(
 366             store.dispatch,
 367             { softwareProductId, version }
 368         ).then(() => {
 369             expect(store.getState()).toEqual(expectedStore);
 370         });
 371     });
 372
 373     //**
 374     //** DELETE
 375     //**
 376     it('Delete Software Products Processes', () => {
 377         const softwareProductProcessesList = VSPProcessStoreWithArtifactNameFactory.buildList(
 378             1
 379         );
 380         const currentSoftwareProduct = VSPEditorFactory.build();
 381
 382         deepFreeze(softwareProductProcessesList);
 383         const store = storeCreator({
 384             softwareProduct: {
 385                 softwareProductProcesses: {
 386                     processesList: softwareProductProcessesList
 387                 },
 388                 softwareProductEditor: {
 389                     data: currentSoftwareProduct
 390                 }
 391             }
 392         });
 393
 394         const processId = softwareProductProcessesList[0].id;
 395         const versionId = version.id;
 396         deepFreeze(store.getState());
 397
 398         const expectedStore = cloneAndSet(
 399             store.getState(),
 400             'softwareProduct.softwareProductProcesses.processesList',
 401             []
 402         );
 403
 404         mockRest.addHandler('destroy', ({ data, options, baseUrl }) => {
 405             expect(baseUrl).toEqual(
 406                 `${restPrefix}/v1.0/vendor-software-products/${softwareProductId}/versions/${versionId}/processes/${processId}`
 407             );
 408             expect(data).toEqual(undefined);
 409             expect(options).toEqual(undefined);
 410             return {
 411                 results: {
 412                     returnCode: 'OK'
 413                 }
 414             };
 415         });
 416
 417         return SoftwareProductProcessesActionHelper.deleteProcess(
 418             store.dispatch,
 419             {
 420                 process: softwareProductProcessesList[0],
 421                 softwareProductId,
 422                 version
 423             }
 424         ).then(() => {
 425             expect(store.getState()).toEqual(expectedStore);
 426         });
 427     });
 428
 429     it('Validating Software Products Processes Delete confirmation', () => {
 430         const store = storeCreator();
 431         deepFreeze(store.getState());
 432
 433         let process = VSPProcessStoreFactory.build();
 434         deepFreeze(process);
 435
 436         const expectedStore = cloneAndSet(
 437             store.getState(),
 438             'softwareProduct.softwareProductProcesses.processToDelete',
 439             process
 440         );
 441
 442         return SoftwareProductProcessesActionHelper.openDeleteProcessesConfirm(
 443             store.dispatch,
 444             { process }
 445         );
 446
 447         expect(store.getState()).toEqual(expectedStore);
 448     });
 449
 450     it('Validating Software Products Processes Cancel Delete', () => {
 451         const store = storeCreator();
 452         deepFreeze(store.getState());
 453
 454         const expectedStore = cloneAndSet(
 455             store.getState(),
 456             'softwareProduct.softwareProductProcesses.processToDelete',
 457             false
 458         );
 459
 460         SoftwareProductProcessesActionHelper.hideDeleteConfirm(store.dispatch);
 461
 462         expect(store.getState()).toEqual(expectedStore);
 463     });
 464
 465     //**
 466     //** CREATE/EDIT
 467     //**
 468
 469     it('Validating close Software Products Processes from editing mode', () => {
 470         const store = storeCreator();
 471         deepFreeze(store.getState());
 472
 473         const expectedStore = cloneAndSet(
 474             store.getState(),
 475             'softwareProduct.softwareProductProcesses.processesEditor',
 476             {}
 477         );
 478
 479         SoftwareProductProcessesActionHelper.closeEditor(store.dispatch);
 480         expect(store.getState()).toEqual(expectedStore);
 481     });
 482
 483     it('Validating open Software Products Processes for editing', () => {
 484         const store = storeCreator();
 485         deepFreeze(store.getState());
 486
 487         let process = { name: 'aa', description: 'xx' };
 488         deepFreeze(process);
 489
 490         const expectedStore = cloneAndSet(
 491             store.getState(),
 492             'softwareProduct.softwareProductProcesses.processesEditor.data',
 493             process
 494         );
 495
 496         SoftwareProductProcessesActionHelper.openEditor(store.dispatch, {
 497             process
 498         });
 499         expect(
 500             store.getState().softwareProduct.softwareProductProcesses
 501                 .processesEditor.data
 502         ).toEqual(
 503             expectedStore.softwareProduct.softwareProductProcesses
 504                 .processesEditor.data
 505         );
 506     });
 507 });