@itentialopensource/adapter-meraki 1.0.4 → 1.2.1

package/test/integration/adapterTestConnectivity.js

@@ -4,8 +4,11 @@
 /* eslint no-unused-vars: warn */
 
 const assert = require('assert');
+const http = require('http');
+const https = require('https');
 const mocha = require('mocha');
-const diagnostics = require('network-diagnostics');
+const ping = require('ping');
+const dnsLookup = require('dns-lookup-promise');
 
 let host;
 process.argv.forEach((val) => {
@@ -16,78 +19,124 @@ process.argv.forEach((val) => {
 
 describe('[integration] Adapter Test', () => {
   context(`Testing network connection on ${host}`, () => {
-    before(() => {
-      diagnostics.setTestURL(host);
-    });
-
     after((done) => {
       done();
     });
 
     it('DNS resolve', (done) => {
-      diagnostics.haveDNS((result) => {
-        try {
-          assert.equal(result, true);
-          done();
-        } catch (error) {
-          done(error);
-        }
-      });
+      dnsLookup(host)
+        .then((addresses) => {
+          try {
+            assert.ok(addresses.length > 0);
+            done();
+          } catch (error) {
+            done(error);
+          }
+        })
+        .catch((err) => {
+          done(err);
+        });
     });
 
     it('Responds to ping', (done) => {
-      diagnostics.havePing((result) => {
-        try {
-          assert.equal(result, true);
-          done();
-        } catch (error) {
-          done(error);
-        }
-      });
+      ping.promise.probe(host)
+        .then((result) => {
+          try {
+            assert.ok(result.alive);
+            done();
+          } catch (error) {
+            done(error);
+          }
+        })
+        .catch((err) => {
+          done(err);
+        });
     });
 
     it('Support HTTP on port 80', (done) => {
-      diagnostics.haveHTTP((result) => {
+      const requestOptions = {
+        host,
+        port: 80,
+        method: 'HEAD'
+      };
+
+      const req = http.request(requestOptions, (res) => {
         try {
-          assert.equal(result, true);
+          assert.ok(res.statusCode >= 200 && res.statusCode < 400);
           done();
         } catch (error) {
           done(error);
         }
       });
+
+      req.on('error', (err) => {
+        done(err);
+      });
+
+      req.end();
     });
 
     it('Support HTTPS on port 443', (done) => {
-      diagnostics.haveHTTPS((result) => {
+      const requestOptions = {
+        host,
+        port: 443,
+        method: 'HEAD'
+      };
+
+      const req = https.request(requestOptions, (res) => {
         try {
-          assert.equal(result, true);
+          assert.ok(res.statusCode >= 200 && res.statusCode < 400);
           done();
         } catch (error) {
           done(error);
         }
       });
+
+      req.on('error', (err) => {
+        done(err);
+      });
+
+      req.end();
     });
 
     it('Support IPv4', (done) => {
-      diagnostics.haveIPv4Async((result) => {
-        try {
-          assert.equal(result, true);
-          done();
-        } catch (error) {
-          done(error);
-        }
-      });
+      const options = {
+        family: 4,
+        hints: dnsLookup.ADDRCONFIG
+      };
+
+      dnsLookup.lookup(host, options)
+        .then((address, family) => {
+          try {
+            assert.ok(address !== null && family === 4);
+            done();
+          } catch (error) {
+            done(error);
+          }
+        })
+        .catch((err) => {
+          done(err);
+        });
     });
 
     it('Support IPv6', (done) => {
-      diagnostics.haveIPv6Async((result) => {
-        try {
-          assert.equal(result, true);
-          done();
-        } catch (error) {
-          done(error);
-        }
-      });
+      const options = {
+        family: 6,
+        hints: dnsLookup.ADDRCONFIG
+      };
+
+      dnsLookup.lookup(host, options)
+        .then((address, family) => {
+          try {
+            assert.ok(address !== null && family === 6);
+            done();
+          } catch (error) {
+            done(error);
+          }
+        })
+        .catch((err) => {
+          done(err);
+        });
     });
   });
 });

package/test/integration/adapterTestIntegration.js

@@ -8,8 +8,8 @@
 
 // include required items for testing & logging
 const assert = require('assert');
-const path = require('path');
 const fs = require('fs');
+const path = require('path');
 const util = require('util');
 const mocha = require('mocha');
 const winston = require('winston');
@@ -335,6 +335,134 @@ describe('[integration] Meraki 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-meraki-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-meraki-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);
+    });
     /*
     -----------------------------------------------------------------------
     -----------------------------------------------------------------------