Add collaboration feature

[sdc.git] / openecomp-ui / test / licenseModel / test.js

diff --git a/openecomp-ui/test/licenseModel/test.js b/openecomp-ui/test/licenseModel/test.js
index eac1297..6cb2168 100644 (file)
--- a/openecomp-ui/test/licenseModel/test.js
+++ b/openecomp-ui/test/licenseModel/test.js
@@ -16,9 +16,15 @@
 import deepFreeze from 'deep-freeze';
 import mockRest from 'test-utils/MockRest.js';
 import {storeCreator} from 'sdc-app/AppStore.js';
+import {cloneAndSet} from 'test-utils/Util.js';
+import LicenseModelActionHelper from 'sdc-app/onboarding/licenseModel/LicenseModelActionHelper.js';
 import LicenseModelCreationActionHelper from 'sdc-app/onboarding/licenseModel/creation/LicenseModelCreationActionHelper.js';
-
-import {LicenseModelPostFactory, LicenseModelDispatchFactory} from 'test-utils/factories/licenseModel/LicenseModelFactories.js';
+import {LicenseModelPostFactory, LicenseModelDispatchFactory, LicenseModelStoreFactory} from 'test-utils/factories/licenseModel/LicenseModelFactories.js';
+import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
+import {default as CurrentScreenFactory} from 'test-utils/factories/common/CurrentScreenFactory.js';
+import {actionsEnum as VersionControllerActionsEnum} from 'nfvo-components/panel/versionController/VersionControllerConstants.js';
+import {SyncStates} from 'sdc-app/common/merge/MergeEditorConstants.js';
+import {itemTypes} from 'sdc-app/onboarding/versionsPage/VersionsPageConstants.js';
 
 describe('License Model Module Tests', function () {
        it('Add License Model', () => {
@@ -46,4 +52,90 @@ describe('License Model Module Tests', function () {
                        expect(response.value).toEqual(licenseModelIdFromResponse);
                });
        });
+
+       it('Validating readonly screen after submit', () => {
+               const version = VersionFactory.build({}, {isCertified: false});
+               const itemPermissionAndProps = CurrentScreenFactory.build({}, {version});
+               const licenseModel = LicenseModelStoreFactory.build();
+               deepFreeze(licenseModel);
+
+               const store = storeCreator({
+                       currentScreen: {...itemPermissionAndProps},
+                       licenseModel: {
+                               licenseModelEditor: {data: licenseModel},
+                       }
+               });
+               deepFreeze(store.getState());
+
+               const certifiedVersion = {
+                       ...itemPermissionAndProps.props.version,
+                       status: 'Certified'
+               };
+
+               const expectedCurrentScreenProps = {
+                       itemPermission: {
+                               ...itemPermissionAndProps.itemPermission,
+                               isCertified: true
+                       },
+                       props: {
+                               isReadOnlyMode: true,
+                               version: certifiedVersion
+                       }
+               };
+               const expectedSuccessModal = {
+                       cancelButtonText: 'OK',
+                       modalClassName: 'notification-modal',
+                       msg: 'This license model successfully submitted',
+                       timeout: 2000,
+                       title: 'Submit Succeeded',
+                       type: 'success'
+               };
+
+               const versionsList = {
+                       itemType: itemTypes.LICENSE_MODEL,
+                       itemId: licenseModel.id,
+                       versions: [{...certifiedVersion}]
+               };
+
+               let expectedStore = store.getState();
+               expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
+               expectedStore = cloneAndSet(expectedStore, 'currentScreen.props', expectedCurrentScreenProps.props);
+               expectedStore = cloneAndSet(expectedStore, 'modal', expectedSuccessModal);
+               expectedStore = cloneAndSet(expectedStore, 'versionsPage.versionsList', versionsList );
+
+               mockRest.addHandler('put', ({data, options, baseUrl}) => {
+                       expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${licenseModel.id}/versions/${version.id}/actions`);
+                       expect(data).toEqual({action: VersionControllerActionsEnum.SUBMIT});
+                       expect(options).toEqual(undefined);
+                       return {returnCode: 'OK'};
+               });
+
+               mockRest.addHandler('put', ({data, options, baseUrl}) => {
+                       expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${licenseModel.id}/versions/${version.id}/actions`);
+                       expect(data).toEqual({action: VersionControllerActionsEnum.CREATE_PACKAGE});
+                       expect(options).toEqual(undefined);
+                       return {returnCode: 'OK'};
+               });
+
+               mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
+                       expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${licenseModel.id}/versions/${version.id}`);
+                       expect(data).toEqual(undefined);
+                       expect(options).toEqual(undefined);
+                       return {...certifiedVersion, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: false}};
+               });
+
+               mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
+                       expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${licenseModel.id}/versions`);
+                       expect(data).toEqual(undefined);
+                       expect(options).toEqual(undefined);
+                       return {results: [{...certifiedVersion}]};
+               });
+
+               return LicenseModelActionHelper.performSubmitAction(store.dispatch, {
+                       licenseModelId: licenseModel.id,
+                       version
+               }).then(() => {
+                       expect(store.getState()).toEqual(expectedStore);
+               });
+       });
 });