openecomp-ui/test/licenseModel/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 import deepFreeze from 'deep-freeze';
  17 import mockRest from 'test-utils/MockRest.js';
  18 import { storeCreator } from 'sdc-app/AppStore.js';
  19 import { cloneAndSet } from 'test-utils/Util.js';
  20 import LicenseModelActionHelper from 'sdc-app/onboarding/licenseModel/LicenseModelActionHelper.js';
  21 import LicenseModelCreationActionHelper from 'sdc-app/onboarding/licenseModel/creation/LicenseModelCreationActionHelper.js';
  22 import {
  23     LicenseModelPostFactory,
  24     LicenseModelDispatchFactory,
  25     LicenseModelStoreFactory
  26 } from 'test-utils/factories/licenseModel/LicenseModelFactories.js';
  27 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  28 import { default as CurrentScreenFactory } from 'test-utils/factories/common/CurrentScreenFactory.js';
  29 import { actionsEnum as VersionControllerActionsEnum } from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
  30 import { SyncStates } from 'sdc-app/common/merge/MergeEditorConstants.js';
  31 import { itemTypes } from 'sdc-app/onboarding/versionsPage/VersionsPageConstants.js';
  32
  33 describe('License Model Module Tests', function() {
  34     it('Add License Model', () => {
  35         const store = storeCreator();
  36         deepFreeze(store.getState());
  37
  38         const licenseModelPostRequest = LicenseModelPostFactory.build();
  39
  40         const licenseModelToAdd = LicenseModelDispatchFactory.build();
  41
  42         const licenseModelIdFromResponse = 'ADDED_ID';
  43
  44         mockRest.addHandler('post', ({ options, data, baseUrl }) => {
  45             expect(baseUrl).toEqual(
  46                 '/onboarding-api/v1.0/vendor-license-models/'
  47             );
  48             expect(data).toEqual(licenseModelPostRequest);
  49             expect(options).toEqual(undefined);
  50             return {
  51                 value: licenseModelIdFromResponse
  52             };
  53         });
  54
  55         return LicenseModelCreationActionHelper.createLicenseModel(
  56             store.dispatch,
  57             {
  58                 licenseModel: licenseModelToAdd
  59             }
  60         ).then(response => {
  61             expect(response.value).toEqual(licenseModelIdFromResponse);
  62         });
  63     });
  64
  65     it('Validating readonly screen after submit', () => {
  66         const version = VersionFactory.build({}, { isCertified: false });
  67         const itemPermissionAndProps = CurrentScreenFactory.build(
  68             {},
  69             { version }
  70         );
  71         const licenseModel = LicenseModelStoreFactory.build();
  72         deepFreeze(licenseModel);
  73
  74         const store = storeCreator({
  75             currentScreen: { ...itemPermissionAndProps },
  76             licenseModel: {
  77                 licenseModelEditor: { data: licenseModel }
  78             }
  79         });
  80         deepFreeze(store.getState());
  81
  82         const certifiedVersion = {
  83             ...itemPermissionAndProps.props.version,
  84             status: 'Certified'
  85         };
  86
  87         const expectedCurrentScreenProps = {
  88             itemPermission: {
  89                 ...itemPermissionAndProps.itemPermission,
  90                 isCertified: true
  91             },
  92             props: {
  93                 isReadOnlyMode: true,
  94                 version: certifiedVersion
  95             }
  96         };
  97         const expectedSuccessModal = {
  98             cancelButtonText: 'OK',
  99             msg: 'This license model successfully submitted',
 100             timeout: 2000,
 101             title: 'Submit Succeeded',
 102             type: 'info'
 103         };
 104
 105         const versionsList = {
 106             itemType: itemTypes.LICENSE_MODEL,
 107             itemId: licenseModel.id,
 108             versions: [{ ...certifiedVersion }]
 109         };
 110
 111         let expectedStore = store.getState();
 112         expectedStore = cloneAndSet(
 113             expectedStore,
 114             'currentScreen.itemPermission',
 115             expectedCurrentScreenProps.itemPermission
 116         );
 117         expectedStore = cloneAndSet(
 118             expectedStore,
 119             'currentScreen.props',
 120             expectedCurrentScreenProps.props
 121         );
 122         expectedStore = cloneAndSet(
 123             expectedStore,
 124             'modal',
 125             expectedSuccessModal
 126         );
 127         expectedStore = cloneAndSet(
 128             expectedStore,
 129             'versionsPage.versionsList',
 130             versionsList
 131         );
 132
 133         mockRest.addHandler('put', ({ data, options, baseUrl }) => {
 134             expect(baseUrl).toEqual(
 135                 `/onboarding-api/v1.0/vendor-license-models/${
 136                     licenseModel.id
 137                 }/versions/${version.id}/actions`
 138             );
 139             expect(data).toEqual({
 140                 action: VersionControllerActionsEnum.SUBMIT
 141             });
 142             expect(options).toEqual(undefined);
 143             return { returnCode: 'OK' };
 144         });
 145
 146         mockRest.addHandler('put', ({ data, options, baseUrl }) => {
 147             expect(baseUrl).toEqual(
 148                 `/onboarding-api/v1.0/vendor-license-models/${
 149                     licenseModel.id
 150                 }/versions/${version.id}/actions`
 151             );
 152             expect(data).toEqual({
 153                 action: VersionControllerActionsEnum.CREATE_PACKAGE
 154             });
 155             expect(options).toEqual(undefined);
 156             return { returnCode: 'OK' };
 157         });
 158
 159         mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
 160             expect(baseUrl).toEqual(
 161                 `/onboarding-api/v1.0/items/${licenseModel.id}/versions/${
 162                     version.id
 163                 }`
 164             );
 165             expect(data).toEqual(undefined);
 166             expect(options).toEqual(undefined);
 167             return {
 168                 ...certifiedVersion,
 169                 state: {
 170                     synchronizationState: SyncStates.UP_TO_DATE,
 171                     dirty: false
 172                 }
 173             };
 174         });
 175
 176         mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
 177             expect(baseUrl).toEqual(
 178                 `/onboarding-api/v1.0/items/${licenseModel.id}`
 179             );
 180             expect(data).toEqual(undefined);
 181             expect(options).toEqual(undefined);
 182             return { ...certifiedVersion };
 183         });
 184
 185         mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
 186             expect(baseUrl).toEqual(
 187                 `/onboarding-api/v1.0/items/${licenseModel.id}/versions`
 188             );
 189             expect(data).toEqual(undefined);
 190             expect(options).toEqual(undefined);
 191             return { results: [{ ...certifiedVersion }] };
 192         });
 193
 194         return LicenseModelActionHelper.performSubmitAction(store.dispatch, {
 195             licenseModelId: licenseModel.id,
 196             version
 197         }).then(() => {
 198             expect(store.getState()).toEqual(expectedStore);
 199         });
 200     });
 201 });