@itentialopensource/adapter-paragon_insights 0.1.2 → 0.2.0

package/test/integration/adapterTestIntegration.js

@@ -9,13 +9,13 @@
 // include required items for testing & logging
 const assert = require('assert');
 const fs = require('fs');
-const mocha = require('mocha');
 const path = require('path');
+const util = require('util');
+const mocha = require('mocha');
 const winston = require('winston');
 const { expect } = require('chai');
 const { use } = require('chai');
 const td = require('testdouble');
-const util = require('util');
 
 const anything = td.matchers.anything();
 
@@ -335,6 +335,134 @@ describe('[integration] Paragon_insights Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    // broker tests
+    describe('#getDevicesFiltered - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          const opts = {
+            filter: {
+              name: 'deviceName'
+            }
+          };
+          a.getDevicesFiltered(opts, (data, error) => {
+            try {
+              if (stub) {
+                if (samProps.devicebroker.getDevicesFiltered[0].handleFailure === 'ignore') {
+                  assert.equal(null, error);
+                  assert.notEqual(undefined, data);
+                  assert.notEqual(null, data);
+                  assert.equal(0, data.total);
+                  assert.equal(0, data.list.length);
+                } else {
+                  const displayE = 'Error 400 received on request';
+                  runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+                }
+              } else {
+                runCommonAsserts(data, error);
+              }
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#iapGetDeviceCount - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          const opts = {
+            filter: {
+              name: 'deviceName'
+            }
+          };
+          a.iapGetDeviceCount((data, error) => {
+            try {
+              if (stub) {
+                if (samProps.devicebroker.getDevicesFiltered[0].handleFailure === 'ignore') {
+                  assert.equal(null, error);
+                  assert.notEqual(undefined, data);
+                  assert.notEqual(null, data);
+                  assert.equal(0, data.count);
+                } else {
+                  const displayE = 'Error 400 received on request';
+                  runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+                }
+              } else {
+                runCommonAsserts(data, error);
+              }
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    // exposed cache tests
+    describe('#iapPopulateEntityCache - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.iapPopulateEntityCache('Device', (data, error) => {
+            try {
+              if (stub) {
+                assert.equal(null, data);
+                assert.notEqual(undefined, error);
+                assert.notEqual(null, error);
+                done();
+              } else {
+                assert.equal(undefined, error);
+                assert.equal('success', data[0]);
+                done();
+              }
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#iapRetrieveEntitiesCache - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.iapRetrieveEntitiesCache('Device', {}, (data, error) => {
+            try {
+              if (stub) {
+                assert.equal(null, data);
+                assert.notEqual(null, error);
+                assert.notEqual(undefined, error);
+              } else {
+                assert.equal(undefined, error);
+                assert.notEqual(null, data);
+                assert.notEqual(undefined, data);
+              }
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
     /*
     -----------------------------------------------------------------------
     -----------------------------------------------------------------------
@@ -12265,5 +12393,515 @@ describe('[integration] Paragon_insights Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#retrieveDeviceTriggerInfo - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveDeviceTriggerInfo('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Configuration', 'retrieveDeviceTriggerInfo', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeIcebergDevicesFromGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIcebergDevicesFromGroup('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Configuration', 'removeIcebergDevicesFromGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeIcebergNetworkGroupNetworkGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIcebergNetworkGroupNetworkGroupById('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Configuration', 'removeIcebergNetworkGroupNetworkGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestSettingsPaa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestSettingsPaa(null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestSettingsPaa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteHealthbotIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteHealthbotIngestPaaByPaaName('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'deleteHealthbotIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestPaaByPaaName('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configUpdateIngestPaaByPaaNameBodyParam = {};
+    describe('#updateIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateIngestPaaByPaaName('fakedata', configUpdateIngestPaaByPaaNameBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'updateIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configCreateIngestPaaByPaaNameBodyParam = {};
+    describe('#createIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createIngestPaaByPaaName('fakedata', configCreateIngestPaaByPaaNameBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'createIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteHealthbotIngestIfa((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'deleteHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfa(null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configCreateHealthbotIngestIfaBodyParam = {};
+    describe('#createHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createHealthbotIngestIfa(configCreateHealthbotIngestIfaBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'createHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configUpdateHealthbotIngestIfaBodyParam = {};
+    describe('#updateHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateHealthbotIngestIfa(configUpdateHealthbotIngestIfaBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'updateHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfaDeviceIds - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfaDeviceIds(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response[0]);
+                assert.equal('string', data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfaDeviceIds', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfaDevices - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfaDevices(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfaDevices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteHealthbotIngestIfaDeviceById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'deleteHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfaDeviceById(555, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configCreateHealthbotIngestIfaDeviceByIdBodyParam = {};
+    describe('#createHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createHealthbotIngestIfaDeviceById(555, configCreateHealthbotIngestIfaDeviceByIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'createHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configUpdateHealthbotIngestIfaDeviceByIdBodyParam = {};
+    describe('#updateHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateHealthbotIngestIfaDeviceById('fakedata', configUpdateHealthbotIngestIfaDeviceByIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'updateHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const utilityPostJunosEncodeBodyParam = {};
+    describe('#postJunosEncode - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postJunosEncode(utilityPostJunosEncodeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Utility', 'postJunosEncode', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const utilityPostJunosDecodeBodyParam = {};
+    describe('#postJunosDecode - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postJunosDecode(utilityPostJunosDecodeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Utility', 'postJunosDecode', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });