openecomp-ui/test/softwareProduct/components/monitoring/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 mockRest from 'test-utils/MockRest.js';
  18 import {storeCreator} from 'sdc-app/AppStore.js';
  19 import SoftwareProductComponentsMonitoringConstants from 'sdc-app/onboarding/softwareProduct/components/monitoring/SoftwareProductComponentsMonitoringConstants.js';
  20 import SoftwareProductComponentsMonitoringActionHelper from 'sdc-app/onboarding/softwareProduct/components/monitoring/SoftwareProductComponentsMonitoringActionHelper.js';
  21
  22 import {VSPComponentsMonitoringRestFactory} from 'test-utils/factories/softwareProduct/SoftwareProductComponentsMonitoringFactories.js';
  23 import VersionControllerUtilsFactory from 'test-utils/factories/softwareProduct/VersionControllerUtilsFactory.js';
  24
  25 const softwareProductId = '123';
  26 const componentId = '123';
  27 const version = VersionControllerUtilsFactory.build().version;
  28
  29 describe('Software Product Components Monitoring Module Tests', function () {
  30
  31         let store;
  32
  33         beforeEach(()=> {
  34                 store = storeCreator();
  35         });
  36
  37
  38         it('Fetch for existing files - no files', done => {
  39
  40                 let emptyResult = VSPComponentsMonitoringRestFactory.build();
  41
  42                 mockRest.addHandler('fetch', ({ baseUrl}) => {
  43                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp`);
  44                         return emptyResult;
  45                 });
  46
  47                 SoftwareProductComponentsMonitoringActionHelper.fetchExistingFiles(store.dispatch, {
  48                         softwareProductId,
  49                         version,
  50                         componentId
  51                 });
  52                 setTimeout(()=> {
  53                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
  54                         expect(monitoring.pollFilename).toEqual(emptyResult.snmpPoll);
  55                         expect(monitoring.trapFilename).toEqual(emptyResult.snmpTrap);
  56                         done();
  57                 }, 0);
  58
  59         });
  60
  61         it('Fetch for existing files - only snmp trap file exists', done => {
  62                 let response = VSPComponentsMonitoringRestFactory.build({}, {snmpTrapFlag: true});
  63
  64                 mockRest.addHandler('fetch', ({ baseUrl}) => {
  65                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp`);
  66                         return response;
  67                 });
  68
  69                 SoftwareProductComponentsMonitoringActionHelper.fetchExistingFiles(store.dispatch, {
  70                         softwareProductId,
  71                         version,
  72                         componentId
  73                 });
  74                 setTimeout(()=> {
  75                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
  76                         expect(monitoring.pollFilename).toEqual(response.snmpPoll);
  77                         expect(monitoring.trapFilename).toEqual(response.snmpTrap);
  78                         done();
  79                 }, 0);
  80         });
  81
  82         it('Fetch for existing files - only snmp poll file exists', done => {
  83                 let response  = VSPComponentsMonitoringRestFactory.build({}, {snmpPollFlag: true});
  84
  85                 mockRest.addHandler('fetch', ({baseUrl}) => {
  86                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp`);
  87                         return response;
  88                 });
  89
  90                 SoftwareProductComponentsMonitoringActionHelper.fetchExistingFiles(store.dispatch, {
  91                         softwareProductId,
  92                         version,
  93                         componentId
  94                 });
  95                 setTimeout(()=> {
  96                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
  97                         expect(monitoring.pollFilename).toEqual(response.snmpPoll);
  98                         expect(monitoring.trapFilename).toEqual(response.snmpTrap);
  99                         done();
 100                 }, 0);
 101         });
 102
 103         it('Fetch for existing files - both files exist', done => {
 104                 let response = VSPComponentsMonitoringRestFactory.build({}, {snmpTrapFlag: true, snmpPollFlag: true});
 105
 106                 mockRest.addHandler('fetch', ({baseUrl}) => {
 107                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp`);
 108                         return response;
 109                 });
 110
 111                 SoftwareProductComponentsMonitoringActionHelper.fetchExistingFiles(store.dispatch, {
 112                         softwareProductId,
 113                         version,
 114                         componentId
 115                 });
 116                 setTimeout(()=> {
 117                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
 118                         expect(monitoring.pollFilename).toEqual(response.snmpPoll);
 119                         expect(monitoring.trapFilename).toEqual(response.snmpTrap);
 120                         done();
 121                 }, 0);
 122         });
 123
 124         it('Upload snmp trap file', done => {
 125
 126                 mockRest.addHandler('post', ({baseUrl}) => {
 127                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp-trap/upload`);
 128                         return {};
 129                 });
 130                 var debug = {hello: 'world'};
 131                 let file = new Blob([JSON.stringify(debug, null, 2)], {type: 'application/json'});;
 132                 let formData = new FormData();
 133                 formData.append('upload', file);
 134                 SoftwareProductComponentsMonitoringActionHelper.uploadSnmpFile(store.dispatch, {
 135                         softwareProductId,
 136                         version,
 137                         componentId,
 138                         formData,
 139                         fileSize: file.size,
 140                         type: SoftwareProductComponentsMonitoringConstants.SNMP_TRAP
 141                 });
 142                 setTimeout(()=> {
 143                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
 144                         expect(monitoring.pollFilename).toEqual(undefined);
 145                         expect(monitoring.trapFilename).toEqual('blob');
 146                         done();
 147                 }, 0);
 148         });
 149
 150         it('Upload snmp poll file', done => {
 151                 mockRest.addHandler('post', ({baseUrl}) => {
 152                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp/upload`);
 153                         return {};
 154                 });
 155                 var debug = {hello: 'world'};
 156                 let file = new Blob([JSON.stringify(debug, null, 2)], {type: 'application/json'});;
 157                 let formData = new FormData();
 158                 formData.append('upload', file);
 159                 SoftwareProductComponentsMonitoringActionHelper.uploadSnmpFile(store.dispatch, {
 160                         softwareProductId,
 161                         version,
 162                         componentId,
 163                         formData,
 164                         fileSize: file.size,
 165                         type: SoftwareProductComponentsMonitoringConstants.SNMP_POLL
 166                 });
 167                 setTimeout(()=> {
 168                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
 169                         expect(monitoring.pollFilename).toEqual('blob');
 170                         expect(monitoring.trapFilename).toEqual(undefined);
 171                         done();
 172                 }, 0);
 173         });
 174
 175         it('Delete snmp trap file', done => {
 176                 mockRest.addHandler('destroy', ({baseUrl}) => {
 177                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp-trap`);
 178                         return {};
 179                 });
 180                 SoftwareProductComponentsMonitoringActionHelper.deleteSnmpFile(store.dispatch, {
 181                         softwareProductId,
 182                         version,
 183                         componentId,
 184                         type: SoftwareProductComponentsMonitoringConstants.SNMP_TRAP
 185                 });
 186                 setTimeout(()=> {
 187                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
 188                         expect(monitoring.trapFilename).toEqual(undefined);
 189                         done();
 190                 }, 0);
 191         });
 192
 193         it('Delete snmp poll file', done => {
 194                 mockRest.addHandler('destroy', ({baseUrl}) => {
 195                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-software-products/${softwareProductId}/versions/${version.id}/components/${componentId}/monitors/snmp`);
 196                         return {};
 197                 });
 198                 SoftwareProductComponentsMonitoringActionHelper.deleteSnmpFile(store.dispatch, {
 199                         softwareProductId,
 200                         version,
 201                         componentId,
 202                         type: SoftwareProductComponentsMonitoringConstants.SNMP_POLL
 203                 });
 204                 setTimeout(()=> {
 205                         var {softwareProduct: {softwareProductComponents: {monitoring}}} = store.getState();
 206                         expect(monitoring.pollFilename).toEqual(undefined);
 207                         done();
 208                 }, 0);
 209         });
 210 });