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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  * Modifications Copyright (C) 2021 Nordix Foundation.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 import deepFreeze from 'deep-freeze';
  18 import mockRest from 'test-utils/MockRest.js';
  19 import {cloneAndSet, buildFromExistingObject} from 'test-utils/Util.js';
  20 import {storeCreator} from 'sdc-app/AppStore.js';
  21
  22 import SoftwareProductCreationActionHelper from 'sdc-app/onboarding/softwareProduct/creation/SoftwareProductCreationActionHelper.js';
  23 import SoftwareProductActionHelper from 'sdc-app/onboarding/softwareProduct/SoftwareProductActionHelper.js';
  24 import SoftwareProductCategoriesHelper from 'sdc-app/onboarding/softwareProduct/SoftwareProductCategoriesHelper.js';
  25 import {forms} from 'sdc-app/onboarding/softwareProduct/SoftwareProductConstants.js';
  26 import ValidationHelper from 'sdc-app/common/helpers/ValidationHelper.js';
  27
  28 import {VSPEditorFactory, VSPEditorPostFactory, VSPEditorFactoryWithLicensingData, VSPEditorPostFactoryWithLicensingData} from 'test-utils/factories/softwareProduct/SoftwareProductEditorFactories.js';
  29 import {CategoryFactory}  from 'test-utils/factories/softwareProduct/VSPCategoriesFactory.js';
  30 import {heatSetupManifest} from 'test-utils/factories/softwareProduct/SoftwareProductAttachmentsFactories.js';
  31
  32 import { FeatureGroupStoreFactory as FeatureGroup} from 'test-utils/factories/licenseModel/FeatureGroupFactories.js';
  33 import {LicenseAgreementStoreFactory as LicenseAgreement} from 'test-utils/factories/licenseModel/LicenseAgreementFactories.js';
  34
  35 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  36 import {InitializedCurrentScreenFactory} from 'test-utils/factories/common/CurrentScreenFactory.js';
  37
  38 describe('Software Product Details Module Tests', function () {
  39         it('Get Software Products List', async () => {
  40                 const store = storeCreator();
  41                 deepFreeze(store.getState());
  42                 const softwareProductList = VSPEditorFactory.buildList(2);
  43                 deepFreeze(softwareProductList);
  44                 deepFreeze(store.getState());
  45                 const expectedStore = cloneAndSet(store.getState(), 'softwareProductList', softwareProductList);
  46
  47                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  48                         expect(baseUrl).toEqual('/onboarding-api/v1.0/vendor-software-products/?versionFilter=Draft');
  49                         expect(data).toEqual(undefined);
  50                         expect(options).toEqual(undefined);
  51                         return {results: softwareProductList};
  52                 });
  53
  54                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  55                         expect(baseUrl).toEqual('/onboarding-api/v1.0/vendor-software-products/?versionFilter=Certified');
  56                         expect(data).toEqual(undefined);
  57                         expect(options).toEqual(undefined);
  58                         return {results: []};
  59                 });
  60
  61                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
  62                         expect(baseUrl).toEqual('/onboarding-api/v1.0/vendor-software-products/?Status=ARCHIVED');
  63                         expect(data).toEqual(undefined);
  64                         expect(options).toEqual(undefined);
  65                         return {results: []};
  66                 });
  67
  68                 await SoftwareProductActionHelper.fetchSoftwareProductList(store.dispatch);
  69                 await SoftwareProductActionHelper.fetchFinalizedSoftwareProductList(store.dispatch);
  70                 await SoftwareProductActionHelper.fetchArchivedSoftwareProductList(store.dispatch);
  71
  72                 expect(store.getState()).toEqual(expectedStore);
  73         });
  74
  75         it('Add Software Product', () => {
  76                 const store = storeCreator();
  77                 deepFreeze(store.getState());
  78
  79                 const softwareProductPostRequest = VSPEditorPostFactory.build();
  80                 deepFreeze(softwareProductPostRequest);
  81                 const idFromResponse = '1';
  82                 const expectedVSP = VSPEditorPostFactory.build({id: idFromResponse, vendorId: softwareProductPostRequest.vendorId});
  83                 deepFreeze(expectedVSP);
  84
  85                 mockRest.addHandler('post', ({options, data, baseUrl}) => {
  86                         expect(baseUrl).toEqual('/onboarding-api/v1.0/vendor-software-products/');
  87                         expect(data).toEqual(softwareProductPostRequest);
  88                         expect(options).toEqual(undefined);
  89                         return {
  90                                 vspId: idFromResponse
  91                         };
  92                 });
  93
  94                 return SoftwareProductCreationActionHelper.createSoftwareProduct(store.dispatch, {
  95                         softwareProduct: softwareProductPostRequest
  96                 }).then((response) => {
  97                         expect(response.vspId).toEqual(idFromResponse);
  98                 });
  99         });
 100
 101         it('Fetch Software Product with manifest', () => {
 102                 const store = storeCreator();
 103                 deepFreeze(store.getState());
 104
 105                 const softwareProductPostRequest = VSPEditorPostFactory.build();
 106                 deepFreeze(softwareProductPostRequest);
 107
 108                 const expectedGenericInfo = {
 109                         'name': {
 110                                 isValid: true,
 111                                 errorText: '',
 112                                 validations: [{type: 'validateName', data: true}, {type: 'maxLength', data: 25}, {
 113                                         type: 'required',
 114                                         data: true
 115                                 }]
 116                         },
 117                         'description': {
 118                                 isValid: true,
 119                                 errorText: '',
 120                                 validations: [{type: 'validateName', data: true}, {type: 'required', data: true}]
 121                         }
 122                 };
 123                 const expectedFormName = forms.VENDOR_SOFTWARE_PRODUCT_DETAILS;
 124
 125                 const idFromResponse = '1';
 126                 const version = { id: '0.1', label: '0.1'};
 127                 const expectedVSP = VSPEditorPostFactory.build({id: idFromResponse, vendorId: softwareProductPostRequest.vendorId});
 128                 deepFreeze(expectedVSP);
 129                 let expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductEditor.data', expectedVSP);
 130                 expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductEditor.genericFieldInfo', expectedGenericInfo);
 131                 expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductEditor.formName', expectedFormName);
 132                 expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductQuestionnaire', {qdata: {}, dataMap: {}, qgenericFieldInfo: {}});
 133
 134                 expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductAttachments.heatValidation', {
 135                         'attachmentsTree': {},
 136                         'errorList': [],
 137                         'selectedNode': 'All'
 138                 });
 139                 let manifest = heatSetupManifest.build();
 140                 expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductAttachments.heatSetup', manifest);
 141
 142                 const expectedCurrentScreen = InitializedCurrentScreenFactory.build();
 143                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreen.itemPermission);
 144                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.props', expectedCurrentScreen.props);
 145
 146                 mockRest.addHandler('post', ({options, data, baseUrl}) => {
 147                         expect(baseUrl).toEqual('/onboarding-api/v1.0/vendor-software-products/');
 148                         expect(data).toEqual(softwareProductPostRequest);
 149                         expect(options).toEqual(undefined);
 150                         return {
 151                                 vspId: idFromResponse,
 152                                 version
 153                         };
 154                 });
 155
 156                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 157                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${idFromResponse}/versions/${version.id}`);
 158                         expect(data).toEqual(undefined);
 159                         expect(options).toEqual(undefined);
 160                         return expectedVSP;
 161                 });
 162
 163                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 164                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${idFromResponse}/versions/${version.id}/questionnaire`);
 165                         expect(data).toEqual(undefined);
 166                         expect(options).toEqual(undefined);
 167                         return {data: JSON.stringify({}), schema: JSON.stringify({})};
 168                 });
 169
 170                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 171                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${idFromResponse}/versions/${version.id}/orchestration-template-candidate/manifest`);
 172                         expect(data).toEqual(undefined);
 173                         expect(options).toEqual(undefined);
 174                         return manifest;
 175                 });
 176
 177                 return SoftwareProductCreationActionHelper.createSoftwareProduct(store.dispatch, {
 178                         softwareProduct: softwareProductPostRequest
 179                 }).then(() => {
 180                         return SoftwareProductActionHelper.fetchSoftwareProduct(store.dispatch, {softwareProductId: idFromResponse, version});
 181                 }).then(() => {
 182                         return SoftwareProductActionHelper.loadSoftwareProductHeatCandidate(store.dispatch, {softwareProductId: idFromResponse, version});
 183                 }).then(() => {
 184                         expect(store.getState()).toEqual(expectedStore);
 185                         let newName = 'newName';
 186                         expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductEditor.formReady', null);
 187                         ValidationHelper.dataChanged(store.dispatch, {deltaData: {'name': newName}, formName: forms.VENDOR_SOFTWARE_PRODUCT_DETAILS});
 188                         expectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductEditor.data.name', newName);
 189                         expect(store.getState()).toEqual(expectedStore);
 190                 });
 191         });
 192
 193         it('Load and edit Software Product licensing data', () => {
 194                 const store = storeCreator();
 195
 196                 const softwareProductPostRequest = VSPEditorPostFactory.build();
 197                 deepFreeze(softwareProductPostRequest);
 198
 199                 const licenseModelId = softwareProductPostRequest.vendorId;
 200                 const LMVersion = VersionFactory.build();
 201                 const secondLicenseModelId = 'secondLicenseModelId';
 202
 203                 let FG1 = FeatureGroup.build();
 204                 let LA1 = LicenseAgreement.build({
 205                         featureGroupsIds: [FG1.id]
 206                 });
 207
 208                 let FG2 = FeatureGroup.build();
 209                 let LA2 = LicenseAgreement.build({
 210                         featureGroupsIds: [FG2.id]
 211                 });
 212
 213                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 214                         expect(baseUrl).toEqual('/sdc1/feProxy/rest/v1/categories/resources/');
 215                         expect(data).toEqual(undefined);
 216                         expect(options).toEqual(undefined);
 217                         return [];
 218                 });
 219
 220                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 221                         expect(baseUrl).toEqual('/sdc1/feProxy/rest/v1/catalog/model/');
 222                         expect(data).toEqual(undefined);
 223                         expect(options).toEqual(undefined);
 224                         return [];
 225                 });
 226
 227                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 228                         expect(baseUrl).toEqual('/onboarding-api/v1.0/vendor-license-models/?versionFilter=Certified');
 229                         expect(data).toEqual(undefined);
 230                         expect(options).toEqual(undefined);
 231                         return {results: []};
 232                 });
 233
 234                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 235                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${licenseModelId}/versions/${LMVersion.id}`);
 236                         expect(data).toEqual(undefined);
 237                         expect(options).toEqual(undefined);
 238                         return {results: {}};
 239                 });
 240
 241                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 242                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${licenseModelId}/versions/${LMVersion.id}/license-agreements`);
 243                         expect(data).toEqual(undefined);
 244                         expect(options).toEqual(undefined);
 245                         return {results: [LA1]};
 246                 });
 247
 248                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 249                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${licenseModelId}/versions/${LMVersion.id}/feature-groups`);
 250                         expect(data).toEqual(undefined);
 251                         expect(options).toEqual(undefined);
 252                         return {results: [FG1]};
 253                 });
 254
 255                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 256                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${secondLicenseModelId}/versions/${LMVersion.id}`);
 257                         expect(data).toEqual(undefined);
 258                         expect(options).toEqual(undefined);
 259                         return {results: {}};
 260                 });
 261
 262                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 263                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${secondLicenseModelId}/versions/${LMVersion.id}/license-agreements`);
 264                         expect(data).toEqual(undefined);
 265                         expect(options).toEqual(undefined);
 266                         return {results: [LA2]};
 267                 });
 268
 269                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 270                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${secondLicenseModelId}/versions/${LMVersion.id}/feature-groups`);
 271                         expect(data).toEqual(undefined);
 272                         expect(options).toEqual(undefined);
 273                         return {results: [FG2]};
 274                 });
 275
 276                 return SoftwareProductActionHelper.loadSoftwareProductDetailsData(store.dispatch, {licenseModelId, licensingVersion: LMVersion.id}).then(() => {
 277                         let state = store.getState();
 278                         expect(state.licenseModel.licenseAgreement.licenseAgreementList).toEqual([LA1]);
 279                         expect(state.licenseModel.featureGroup.featureGroupsList).toEqual([FG1]);
 280                         return SoftwareProductActionHelper.softwareProductEditorVendorChanged(store.dispatch,
 281                                                 {deltaData: {vendorId: secondLicenseModelId, licensingVersion: LMVersion.id},
 282                                                         formName: forms.VENDOR_SOFTWARE_PRODUCT_DETAILS}
 283                         ).then(() => {
 284                                 let state = store.getState();
 285                                 expect(state.licenseModel.licenseAgreement.licenseAgreementList).toEqual([LA2]);
 286                                 expect(state.licenseModel.featureGroup.featureGroupsList).toEqual([FG2]);
 287                         });
 288                 });
 289         });
 290
 291         it('Save Software product', () => {
 292
 293                 const softwareProduct = VSPEditorFactoryWithLicensingData.build();
 294                 deepFreeze(softwareProduct);
 295
 296                 const version = VersionFactory.build();
 297
 298                 const store = storeCreator({
 299                         softwareProduct: {
 300                                 softwareProductEditor: {data: softwareProduct},
 301                                 softwareProductQuestionnaire: {qdata: 'test', qschema: {type: 'string'}}
 302                         }
 303                 });
 304                 deepFreeze(store.getState());
 305
 306                 const dataForUpdate = {
 307                         name: 'VSP5_UPDATED',
 308                         description: 'A software model for Fortigate._UPDATED'
 309                 };
 310
 311                 const toBeUpdatedSoftwareProductId = softwareProduct.id;
 312                 let  softwareProductUpdateData = VSPEditorPostFactoryWithLicensingData.build(dataForUpdate);
 313                 delete softwareProductUpdateData.version;
 314
 315                 const softwareProductPutRequest = buildFromExistingObject(VSPEditorFactoryWithLicensingData, softwareProductUpdateData, {id: toBeUpdatedSoftwareProductId, version: softwareProduct.version});
 316
 317                 deepFreeze(softwareProductUpdateData);
 318
 319                 const expectedStore = cloneAndSet(store.getState(), 'softwareProductList', [softwareProductPutRequest]);
 320                 const questionnaireData = {
 321                         general: {
 322                                 affinityData: {
 323                                         affinityGrouping: true,
 324                                         antiAffinityGrouping: false
 325                                 }
 326                         }
 327                 };
 328                 deepFreeze(questionnaireData);
 329
 330                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 331                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${toBeUpdatedSoftwareProductId}/versions/${version.id}`);
 332                         expect(data).toEqual(softwareProductUpdateData);
 333                         expect(options).toEqual(undefined);
 334                         return {returnCode: 'OK'};
 335                 });
 336                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 337                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${toBeUpdatedSoftwareProductId}/versions/${version.id}/questionnaire`);
 338                         expect(data).toEqual(questionnaireData);
 339                         expect(options).toEqual(undefined);
 340                         return {returnCode: 'OK'};
 341                 });
 342
 343                 return SoftwareProductActionHelper.updateSoftwareProduct(store.dispatch, {
 344                         softwareProduct: softwareProductPutRequest,
 345                         qdata: questionnaireData,
 346                         version
 347                 }).then(() => {
 348                         expect(store.getState()).toEqual(expectedStore);
 349                 });
 350         });
 351
 352         it('Save Software product data only', () => {
 353
 354                 const softwareProduct = VSPEditorFactoryWithLicensingData.build();
 355                 deepFreeze(softwareProduct);
 356
 357                 const version = VersionFactory.build();
 358
 359                 const store = storeCreator({
 360                         softwareProduct: {
 361                                 softwareProductEditor: {data: softwareProduct},
 362                                 softwareProductQuestionnaire: {qdata: 'test', qschema: {type: 'string'}}
 363                         }
 364                 });
 365                 deepFreeze(store.getState());
 366                 const expectedStore = store.getState();
 367
 368                 const dataForUpdate = {
 369                         name: 'VSP5_UPDATED',
 370                         description: 'A software model for Fortigate._UPDATED'
 371                 };
 372
 373                 const toBeUpdatedSoftwareProductId = softwareProduct.id;
 374                 let  softwareProductUpdateData = VSPEditorPostFactoryWithLicensingData.build(dataForUpdate);
 375                 delete softwareProductUpdateData.version;
 376
 377                 const softwareProductPutRequest = buildFromExistingObject(VSPEditorFactoryWithLicensingData, softwareProductUpdateData, {id: toBeUpdatedSoftwareProductId});
 378
 379                 deepFreeze(softwareProductUpdateData);
 380
 381                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 382                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${toBeUpdatedSoftwareProductId}/versions/${version.id}`);
 383                         expect(data).toEqual(softwareProductUpdateData);
 384                         expect(options).toEqual(undefined);
 385                         return {returnCode: 'OK'};
 386                 });
 387
 388                 return SoftwareProductActionHelper.updateSoftwareProductData(store.dispatch, {
 389                         softwareProduct: softwareProductPutRequest,
 390                         version
 391                 }).then(() => {
 392                         expect(store.getState()).toEqual(expectedStore);
 393                 });
 394         });
 395
 396         it('Save Software product questionnaire only', () => {
 397                 const softwareProduct = VSPEditorFactoryWithLicensingData.build();
 398                 deepFreeze(softwareProduct);
 399
 400                 const version = VersionFactory.build();
 401
 402                 const store = storeCreator({
 403                         softwareProduct: {
 404                                 softwareProductEditor: {data: softwareProduct},
 405                                 softwareProductQuestionnaire: {qdata: 'test', qschema: {type: 'string'}}
 406                         }
 407                 });
 408                 deepFreeze(store.getState());
 409                 const expectedStore = store.getState();
 410
 411                 const toBeUpdatedSoftwareProductId = softwareProduct.id;
 412                 const questionnaireData = {
 413                         general: {
 414                                 affinityData: {
 415                                         affinityGrouping: true,
 416                                         antiAffinityGrouping: false
 417                                 }
 418                         }
 419                 };
 420                 deepFreeze(questionnaireData);
 421
 422                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 423                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${toBeUpdatedSoftwareProductId}/versions/${version.id}/questionnaire`);
 424                         expect(data).toEqual(questionnaireData);
 425                         expect(options).toEqual(undefined);
 426                         return {returnCode: 'OK'};
 427                 });
 428
 429                 return SoftwareProductActionHelper.updateSoftwareProductQuestionnaire(store.dispatch, {
 430                         softwareProductId: softwareProduct.id,
 431                         version,
 432                         qdata: questionnaireData
 433                 }).then(() => {
 434                         expect(store.getState()).toEqual(expectedStore);
 435                 });
 436         });
 437
 438         it('Handle category without subcategories', () => {
 439
 440                 const categories = CategoryFactory.buildList(3);
 441                 categories[0].subcategories = CategoryFactory.buildList(3);
 442                 categories[2].subcategories = CategoryFactory.buildList(3);
 443
 444                 const category = SoftwareProductCategoriesHelper.getCurrentCategoryOfSubCategory(categories[2].subcategories[2].uniqueId, categories);
 445                 expect(category).toEqual(categories[2].uniqueId);
 446         });
 447
 448 });