openecomp-ui/test/softwareProduct/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
  13  * or implied. See the License for the specific language governing
  14  * permissions and limitations under the License.
  15  */
  16
  17 import deepFreeze from 'deep-freeze';
  18 import mockRest from 'test-utils/MockRest.js';
  19 import { cloneAndSet } from 'test-utils/Util.js';
  20 import { storeCreator } from 'sdc-app/AppStore.js';
  21
  22 import SoftwareProductActionHelper from 'sdc-app/onboarding/softwareProduct/SoftwareProductActionHelper.js';
  23 import { VSPEditorFactoryWithLicensingData } from 'test-utils/factories/softwareProduct/SoftwareProductEditorFactories.js';
  24 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  25 import { default as CurrentScreenFactory } from 'test-utils/factories/common/CurrentScreenFactory.js';
  26 import { actionsEnum as VersionControllerActionsEnum } from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
  27 import { SyncStates } from 'sdc-app/common/merge/MergeEditorConstants.js';
  28 import { itemTypes } from 'sdc-app/onboarding/versionsPage/VersionsPageConstants.js';
  29
  30 describe('Software Product Module Tests', function() {
  31     it('Validating readonly screen after submit', () => {
  32         const version = VersionFactory.build({}, { isCertified: false });
  33         const itemPermissionAndProps = CurrentScreenFactory.build(
  34             {},
  35             { version }
  36         );
  37         const softwareProduct = VSPEditorFactoryWithLicensingData.build();
  38         deepFreeze(softwareProduct);
  39
  40         const store = storeCreator({
  41             currentScreen: { ...itemPermissionAndProps },
  42             softwareProduct: {
  43                 softwareProductEditor: { data: softwareProduct },
  44                 softwareProductQuestionnaire: {
  45                     qdata: 'test',
  46                     qschema: { type: 'string' }
  47                 }
  48             }
  49         });
  50         deepFreeze(store.getState());
  51
  52         const certifiedVersion = {
  53             ...itemPermissionAndProps.props.version,
  54             status: 'Certified'
  55         };
  56
  57         const versionsList = {
  58             itemType: itemTypes.SOFTWARE_PRODUCT,
  59             itemId: softwareProduct.id,
  60             versions: [{ ...certifiedVersion }]
  61         };
  62         const expectedCurrentScreenProps = {
  63             itemPermission: {
  64                 ...itemPermissionAndProps.itemPermission,
  65                 isCertified: true
  66             },
  67             props: {
  68                 isReadOnlyMode: true,
  69                 version: certifiedVersion
  70             }
  71         };
  72         const expectedSuccessModal = {
  73             cancelButtonText: 'OK',
  74             msg: 'This software product successfully submitted',
  75             timeout: 2000,
  76             title: 'Submit Succeeded',
  77             type: 'info'
  78         };
  79
  80         let expectedStore = store.getState();
  81         expectedStore = cloneAndSet(
  82             expectedStore,
  83             'currentScreen.itemPermission',
  84             expectedCurrentScreenProps.itemPermission
  85         );
  86         expectedStore = cloneAndSet(
  87             expectedStore,
  88             'currentScreen.props',
  89             expectedCurrentScreenProps.props
  90         );
  91         expectedStore = cloneAndSet(
  92             expectedStore,
  93             'modal',
  94             expectedSuccessModal
  95         );
  96         expectedStore = cloneAndSet(
  97             expectedStore,
  98             'versionsPage.versionsList',
  99             versionsList
 100         );
 101
 102         mockRest.addHandler('put', ({ data, options, baseUrl }) => {
 103             expect(baseUrl).toEqual(
 104                 `/onboarding-api/v1.0/vendor-software-products/${
 105                     softwareProduct.id
 106                 }/versions/${version.id}/actions`
 107             );
 108             expect(data).toEqual({
 109                 action: VersionControllerActionsEnum.SUBMIT
 110             });
 111             expect(options).toEqual(undefined);
 112             return { returnCode: 'OK' };
 113         });
 114
 115         mockRest.addHandler('put', ({ data, options, baseUrl }) => {
 116             expect(baseUrl).toEqual(
 117                 `/onboarding-api/v1.0/vendor-software-products/${
 118                     softwareProduct.id
 119                 }/versions/${version.id}/actions`
 120             );
 121             expect(data).toEqual({
 122                 action: VersionControllerActionsEnum.CREATE_PACKAGE
 123             });
 124             expect(options).toEqual(undefined);
 125             return { returnCode: 'OK' };
 126         });
 127
 128         mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
 129             expect(baseUrl).toEqual(
 130                 `/onboarding-api/v1.0/items/${softwareProduct.id}/versions/${
 131                     version.id
 132                 }`
 133             );
 134             expect(data).toEqual(undefined);
 135             expect(options).toEqual(undefined);
 136             return {
 137                 ...certifiedVersion,
 138                 state: {
 139                     synchronizationState: SyncStates.UP_TO_DATE,
 140                     dirty: false
 141                 }
 142             };
 143         });
 144
 145         mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
 146             expect(baseUrl).toEqual(
 147                 `/onboarding-api/v1.0/items/${softwareProduct.id}`
 148             );
 149             expect(data).toEqual(undefined);
 150             expect(options).toEqual(undefined);
 151             return { ...certifiedVersion };
 152         });
 153
 154         mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
 155             expect(baseUrl).toEqual(
 156                 `/onboarding-api/v1.0/items/${softwareProduct.id}/versions`
 157             );
 158             expect(data).toEqual(undefined);
 159             expect(options).toEqual(undefined);
 160             return { results: [{ ...certifiedVersion }] };
 161         });
 162
 163         return SoftwareProductActionHelper.performSubmitAction(store.dispatch, {
 164             softwareProductId: softwareProduct.id,
 165             version
 166         }).then(() => {
 167             expect(store.getState()).toEqual(expectedStore);
 168         });
 169     });
 170 });