openecomp-ui/test/softwareProduct/dependencies/SoftwareProductDependencies.test.js

   1 /*!
   2  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   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 React from 'react';
  18 import {mount} from 'enzyme';
  19 import {mapStateToProps} from 'sdc-app/onboarding/softwareProduct/dependencies/SoftwareProductDependencies.js';
  20 import {
  21         SoftwareProductDependenciesResponseFactory,
  22         SoftwareProductDependenciesStoreFactory} from 'test-utils/factories/softwareProduct/SoftwareProductDependenciesFactories.js';
  23 import {VSPComponentsFactory} from 'test-utils/factories/softwareProduct/SoftwareProductComponentsFactories.js';
  24 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  25 import {storeCreator} from 'sdc-app/AppStore.js';
  26 import {cloneAndSet} from 'test-utils/Util.js';
  27 import mockRest from 'test-utils/MockRest.js';
  28
  29 import SoftwareProductComponentsActionHelper from 'sdc-app/onboarding/softwareProduct/components/SoftwareProductComponentsActionHelper.js';
  30 import {relationTypes, NEW_RULE_TEMP_ID}  from 'sdc-app/onboarding/softwareProduct/dependencies/SoftwareProductDependenciesConstants.js';
  31 import SoftwareProductDependenciesActionHelper from 'sdc-app/onboarding/softwareProduct/dependencies/SoftwareProductDependenciesActionHelper.js';
  32 import SoftwareProductDependenciesView from 'sdc-app/onboarding/softwareProduct/dependencies/SoftwareProductDependenciesView.jsx';
  33 import {VSPEditorFactory} from 'test-utils/factories/softwareProduct/SoftwareProductEditorFactories.js';
  34
  35 function addNewRowElement(arr, data) {
  36         if (data === undefined) {
  37                 arr.push({id: NEW_RULE_TEMP_ID, targetId: null, sourceId: null, relationType: relationTypes.DEPENDS_ON});
  38         } else {
  39                 arr.push(data);
  40         }
  41 }
  42
  43 describe('Software Product Dependencies Module Tests', function () {
  44         const softwareProductId = '555';
  45         const version = VersionFactory.build();
  46
  47
  48         it('mapStateToProps mapper exists', () => {
  49                 expect(mapStateToProps).toBeTruthy();
  50         });
  51
  52         it('Get Software Product Dependencies List', () => {
  53                 const store = storeCreator();
  54                 const dispatch = store.dispatch;
  55
  56                 let DependenciesListResponse = SoftwareProductDependenciesResponseFactory.buildList(2);
  57                 let DependenciesListStore = DependenciesListResponse.map(dependency => SoftwareProductDependenciesStoreFactory.build(dependency));
  58                 addNewRowElement(DependenciesListStore);
  59                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductDependencies', DependenciesListStore);
  60
  61                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
  62                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
  63                         expect(data).toEqual(undefined);
  64                         expect(options).toEqual(undefined);
  65                         return {results: DependenciesListResponse};
  66                 });
  67
  68                 return SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version}).then(() => {
  69                         const state = store.getState();
  70                         const depndenciesWithGeneratedId = state.softwareProduct.softwareProductDependencies;
  71                         const currentDependencies = expectedStore.softwareProduct.softwareProductDependencies;
  72                         let expectedStoreDependencies = currentDependencies.map((dependency, index) => ({...dependency, id: depndenciesWithGeneratedId[index].id}));
  73                         const newExpectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductDependencies', expectedStoreDependencies);
  74                         expect(state).toEqual(newExpectedStore);
  75                 });
  76         });
  77
  78         /*
  79         Test update:
  80         - fetch initial item
  81         - update existing item
  82         - auto fetch again
  83          */
  84         it('Update Software Product Dependency', () => {
  85                 const store = storeCreator();
  86                 const dispatch = store.dispatch;
  87
  88                 let DependenciesListResponse = SoftwareProductDependenciesResponseFactory.buildList(1);
  89                 let DependenciesListStore = DependenciesListResponse.map(dependency => SoftwareProductDependenciesStoreFactory.build(dependency));
  90                 addNewRowElement(DependenciesListStore);
  91                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductDependencies', DependenciesListStore);
  92
  93                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
  94                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
  95                         expect(data).toEqual(undefined);
  96                         expect(options).toEqual(undefined);
  97                         return {results: DependenciesListResponse};
  98                 });
  99                 return SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version}).then(() => {
 100
 101                         const state = store.getState();
 102                         const depndenciesWithGeneratedId = state.softwareProduct.softwareProductDependencies;
 103                         const currentDependencies = expectedStore.softwareProduct.softwareProductDependencies;
 104                         let expectedStoreDependencies = currentDependencies.map((dependency, index) => ({...dependency, id: depndenciesWithGeneratedId[index].id}));
 105                         let item = expectedStoreDependencies.find((dep) => dep.id !== NEW_RULE_TEMP_ID);
 106                         item.targetId = 'testChangeTarget';
 107                         item.sourceId = 'testChangesource';
 108                         // removing 'new row' from response
 109                         expectedStoreDependencies = expectedStoreDependencies.slice(0, expectedStoreDependencies.length - 1);
 110                         let expDependenciesListStore = expectedStoreDependencies.map(dependency => SoftwareProductDependenciesStoreFactory.build(dependency));
 111
 112                         mockRest.addHandler('put', ({data, options, baseUrl}) => {
 113                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies/${item.id}`);
 114                                 expect(data.targetId).toEqual('testChangeTarget');
 115                                 expect(data.sourceId).toEqual('testChangesource');
 116                                 expect(options).toEqual(undefined);
 117                                 return {results: null};
 118                         });
 119                         mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 120                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 121                                 expect(data).toEqual(undefined);
 122                                 expect(options).toEqual(undefined);
 123                                 return {results: expDependenciesListStore};
 124                         });
 125
 126                         addNewRowElement(expectedStoreDependencies);
 127                         const newExpectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductDependencies', expectedStoreDependencies);
 128                         return SoftwareProductDependenciesActionHelper.updateDependency(dispatch, {softwareProductId, version, item}).then(() => {
 129                                 const newState = store.getState();
 130                                 expect(newState).toEqual(newExpectedStore);
 131
 132                         });
 133                 });
 134         });
 135
 136         /*
 137         - Fetch item list
 138         - Delete item from list
 139         - Fetch again
 140          */
 141         it('Delete Software Product Dependency', () => {
 142                 const store = storeCreator();
 143                 const dispatch = store.dispatch;
 144                 let DependenciesListResponse = SoftwareProductDependenciesResponseFactory.buildList(1);
 145                 let DependenciesListStore = DependenciesListResponse.map(dependency => SoftwareProductDependenciesStoreFactory.build(dependency));
 146                 addNewRowElement(DependenciesListStore);
 147                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductDependencies', DependenciesListStore);
 148
 149                 let deleteItem = DependenciesListStore.find((dep) => dep.id !== NEW_RULE_TEMP_ID);
 150
 151                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 152                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 153                         expect(data).toEqual(undefined);
 154                         expect(options).toEqual(undefined);
 155                         return {results: DependenciesListResponse};
 156                 });
 157                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
 158                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies/${deleteItem.id}`);
 159                         expect(data).toEqual(undefined);
 160                         expect(options).toEqual(undefined);
 161                         return {results: null};
 162                 });
 163                 return SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version}).then(() => {
 164                         const state = store.getState();
 165                         const depndenciesWithGeneratedId = state.softwareProduct.softwareProductDependencies;
 166                         const currentDependencies = expectedStore.softwareProduct.softwareProductDependencies;
 167                         let expectedStoreDependencies = currentDependencies.map((dependency, index) => ({...dependency, id: depndenciesWithGeneratedId[index].id}))
 168
 169                         const newExpectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductDependencies', expectedStoreDependencies);
 170                         expect(state).toEqual(newExpectedStore);
 171
 172                         expectedStoreDependencies = expectedStoreDependencies.filter((dep) => dep.id !== deleteItem.id);
 173                         const postDeleteExpectedStore = cloneAndSet(expectedStore, 'softwareProduct.softwareProductDependencies', expectedStoreDependencies);
 174
 175                         mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 176                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 177                                 expect(data).toEqual(undefined);
 178                                 expect(options).toEqual(undefined);
 179                                 return {results: []};
 180                         });
 181
 182                         return SoftwareProductDependenciesActionHelper.removeDependency(dispatch, {softwareProductId, version, item: deleteItem}).then(() => {
 183                                 const state = store.getState();
 184                                 const depndenciesWithGeneratedId = state.softwareProduct.softwareProductDependencies;
 185                                 const currentDependencies = postDeleteExpectedStore.softwareProduct.softwareProductDependencies;
 186                                 expect(depndenciesWithGeneratedId).toEqual(currentDependencies);
 187                         });
 188                 });
 189         });
 190
 191         /*
 192         - Create initial list
 193         - Update the new row and make sure there is no API call
 194         - Submit the new row
 195         - Getch data with reset new row and new entity with info from the new item
 196          */
 197
 198         it('Create Software Product Dependency', () => {
 199                 const store = storeCreator();
 200                 const dispatch = store.dispatch;
 201
 202                 let DependenciesListResponse = SoftwareProductDependenciesResponseFactory.buildList(1);
 203                 let DependenciesListStore = DependenciesListResponse.map(dependency => SoftwareProductDependenciesStoreFactory.build(dependency));
 204                 addNewRowElement(DependenciesListStore);
 205                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductDependencies', DependenciesListStore);
 206
 207                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 208                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 209                         expect(data).toEqual(undefined);
 210                         expect(options).toEqual(undefined);
 211                         return {results: DependenciesListResponse};
 212                 });
 213                 return SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version}).then(() => {
 214                         // setting properties on the 'new role' should not call an API
 215                         let addItem = {id: NEW_RULE_TEMP_ID, sourceId: 'sId', targetId : 'tId',relationType: relationTypes.DEPENDS_ON};
 216                         try {
 217                                 SoftwareProductDependenciesActionHelper.updateDependency(dispatch, {softwareProductId, version, item: addItem}).then(()=> {
 218                                         //go to error that fetch was not defined
 219                                 });
 220                         } catch (error) {
 221                                 if(error.name === 'TypeError') {
 222                                         // Expected error because we expected there is no promise
 223                                 } else {
 224                                         fail('Error:' + error);
 225                                 }
 226                         }
 227
 228                         const state = store.getState();
 229                         const depndenciesWithGeneratedId = state.softwareProduct.softwareProductDependencies;
 230                         const currentDependencies = expectedStore.softwareProduct.softwareProductDependencies;
 231                         let expectedStoreDependencies = currentDependencies.map((dependency, index) => ({...dependency, id: depndenciesWithGeneratedId[index].id}));
 232                         // creating the new item
 233                         let item = SoftwareProductDependenciesResponseFactory.buildList(1,
 234                                 {sourceId: 'sId', targetId : 'tId',relationType: relationTypes.DEPENDS_ON})[0];
 235                         addNewRowElement(expectedStoreDependencies, item);
 236                         expectedStoreDependencies = expectedStoreDependencies.filter((dep) => dep.id !== NEW_RULE_TEMP_ID);
 237
 238                         mockRest.addHandler('post', ({data, options, baseUrl}) => {
 239                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 240                                 expect(data.targetId).toEqual('tId');
 241                                 expect(data.sourceId).toEqual('sId');
 242                                 expect(data.id).toEqual(undefined);
 243                                 expect(options).toEqual(undefined);
 244                                 return {results: item.id};
 245                         });
 246                         mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 247                                 expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 248                                 expect(data).toEqual(undefined);
 249                                 expect(options).toEqual(undefined);
 250                                 return {results: expectedStoreDependencies};
 251                         });
 252
 253                         let PostCreateItemListStore = expectedStoreDependencies.map(dependency => SoftwareProductDependenciesStoreFactory.build(dependency));
 254                         addNewRowElement(PostCreateItemListStore);
 255                         const newExpectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductDependencies', PostCreateItemListStore);
 256
 257                         return SoftwareProductDependenciesActionHelper.createDependency(dispatch, {softwareProductId, version, item: addItem}).then(() => {
 258                                 const newState = store.getState();
 259                                 expect(newState.softwareProduct.softwareProductDependencies.length).toEqual(3);
 260                                 expect(newState).toEqual(newExpectedStore);
 261                         });
 262
 263                 });
 264
 265         });
 266
 267
 268         it('Get Software Product Dependencies List with loop, and render to JSX', () => {
 269                 const store = storeCreator();
 270                 const dispatch = store.dispatch;
 271
 272                 let components = VSPComponentsFactory.buildList(2);
 273                 let vspEditor = VSPEditorFactory.build({id: softwareProductId, version});
 274
 275                 let DependenciesListResponse = SoftwareProductDependenciesResponseFactory.buildList(2);
 276                 let firstDependecy = DependenciesListResponse[0];
 277                 let secondDependency = DependenciesListResponse[1];
 278                 firstDependecy.sourceId = components[0].id;
 279                 secondDependency.sourceId = components[1].id;
 280                 firstDependecy.targetId = secondDependency.sourceId;
 281                 secondDependency.targetId = firstDependecy.sourceId;
 282
 283                 let DependenciesListStore = DependenciesListResponse.map(dependency => SoftwareProductDependenciesStoreFactory.build({...dependency, hasCycle: true}));
 284                 addNewRowElement(DependenciesListStore);
 285                 const expectedStore = cloneAndSet(store.getState(), 'softwareProduct.softwareProductDependencies', DependenciesListStore);
 286
 287                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 288                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/component-dependencies`);
 289                         expect(data).toEqual(undefined);
 290                         expect(options).toEqual(undefined);
 291                         return {results: DependenciesListResponse};
 292                 });
 293
 294                 mockRest.addHandler('fetch', ({options, data, baseUrl}) => {
 295                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components`);
 296                         expect(data).toEqual(undefined);
 297                         expect(options).toEqual(undefined);
 298                         return {results: components};
 299                 });
 300
 301                 return SoftwareProductDependenciesActionHelper.fetchDependencies(dispatch, {softwareProductId, version}).then(() => {
 302                         return SoftwareProductComponentsActionHelper.fetchSoftwareProductComponents(dispatch, {softwareProductId, version});
 303                 }).then(() => {
 304                         const state = store.getState();
 305                         state.softwareProduct.softwareProductEditor = {data: vspEditor};
 306                         const depndenciesWithGeneratedId = state.softwareProduct.softwareProductDependencies;
 307                         const currentDependencies = expectedStore.softwareProduct.softwareProductDependencies;
 308                         let expectedStoreDependencies = currentDependencies.map((dependency, index) => ({...dependency, id: depndenciesWithGeneratedId[index].id}));
 309
 310                         const newExpectedStore = {
 311                                 ...expectedStore,
 312                                 softwareProduct: {
 313                                         ...expectedStore.softwareProduct,
 314                                         softwareProductDependencies: expectedStoreDependencies,
 315                                         softwareProductEditor: {data: vspEditor},
 316                                         softwareProductComponents: {
 317                                                 ...expectedStore.softwareProduct.softwareProductComponents,
 318                                                 componentsList: components
 319                                         }
 320                                 }
 321                         };
 322
 323                         expect(state).toEqual(newExpectedStore);
 324
 325                         const props = mapStateToProps(state);
 326                         expect(props.softwareProductDependencies).toEqual(expectedStoreDependencies);
 327                         const wrapper = mount(<SoftwareProductDependenciesView {...props}/>);
 328                         expect(wrapper).toBeTruthy();
 329                 });
 330         });
 331
 332 });