@itentialopensource/adapter-meraki 0.8.3 → 0.8.4

package/test/unit/adapterTestUnit.js

@@ -4,6 +4,7 @@
 /* global describe it log pronghornProps */
 /* eslint global-require: warn */
 /* eslint no-unused-vars: warn */
+/* eslint import/no-dynamic-require:warn */
 
 // include required items for testing & logging
 const assert = require('assert');
@@ -18,22 +19,31 @@ const { use } = require('chai');
 const td = require('testdouble');
 
 const anything = td.matchers.anything();
-
-// stub and attemptTimeout are used throughout the code so set them here
 let logLevel = 'none';
-const stub = true;
 const isRapidFail = false;
-const attemptTimeout = 600000;
+
+// read in the properties from the sampleProperties files
+let adaptdir = __dirname;
+if (adaptdir.endsWith('/test/integration')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 17);
+} else if (adaptdir.endsWith('/test/unit')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 10);
+}
+const samProps = require(`${adaptdir}/sampleProperties.json`).properties;
 
 // these variables can be changed to run in integrated mode so easier to set them here
 // always check these in with bogus data!!!
-const host = 'replace.hostorip.here';
-const username = 'username';
-const password = 'password';
-const protocol = 'http';
-const port = 80;
-const sslenable = false;
-const sslinvalid = false;
+samProps.stub = true;
+samProps.host = 'replace.hostorip.here';
+samProps.authentication.username = 'username';
+samProps.authentication.password = 'password';
+samProps.protocol = 'http';
+samProps.port = 80;
+samProps.ssl.enabled = false;
+samProps.ssl.accept_invalid_cert = false;
+samProps.request.attempt_timeout = 60000;
+const attemptTimeout = samProps.request.attempt_timeout;
+const { stub } = samProps;
 
 // these are the adapter properties. You generally should not need to alter
 // any of these after they are initially set up
@@ -45,102 +55,7 @@ global.pronghornProps = {
     adapters: [{
       id: 'Test-meraki',
       type: 'Meraki',
-      properties: {
-        host,
-        port,
-        base_path: '//api',
-        version: 'v0',
-        cache_location: 'none',
-        encode_pathvars: true,
-        save_metric: false,
-        protocol,
-        stub,
-        authentication: {
-          auth_method: 'basic user_password',
-          username,
-          password,
-          token: '',
-          token_timeout: -1,
-          token_cache: 'local',
-          invalid_token_error: 401,
-          auth_field: 'header.headers.Authorization',
-          auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
-          auth_logging: false,
-          client_id: '',
-          client_secret: '',
-          grant_type: ''
-        },
-        healthcheck: {
-          type: 'none',
-          frequency: 60000,
-          query_object: {}
-        },
-        throttle: {
-          throttle_enabled: false,
-          number_pronghorns: 1,
-          sync_async: 'sync',
-          max_in_queue: 1000,
-          concurrent_max: 1,
-          expire_timeout: 0,
-          avg_runtime: 200,
-          priorities: [
-            {
-              value: 0,
-              percent: 100
-            }
-          ]
-        },
-        request: {
-          number_redirects: 0,
-          number_retries: 3,
-          limit_retry_error: 0,
-          failover_codes: [],
-          attempt_timeout: attemptTimeout,
-          global_request: {
-            payload: {},
-            uriOptions: {},
-            addlHeaders: {},
-            authData: {}
-          },
-          healthcheck_on_timeout: true,
-          return_raw: true,
-          archiving: false,
-          return_request: false
-        },
-        proxy: {
-          enabled: false,
-          host: '',
-          port: 1,
-          protocol: 'http',
-          username: '',
-          password: ''
-        },
-        ssl: {
-          ecdhCurve: '',
-          enabled: sslenable,
-          accept_invalid_cert: sslinvalid,
-          ca_file: '',
-          key_file: '',
-          cert_file: '',
-          secure_protocol: '',
-          ciphers: ''
-        },
-        mongo: {
-          host: '',
-          port: 0,
-          database: '',
-          username,
-          password: '',
-          replSet: '',
-          db_ssl: {
-            enabled: false,
-            accept_invalid_cert: false,
-            ca_file: '',
-            key_file: '',
-            cert_file: ''
-          }
-        }
-      }
+      properties: samProps
     }]
   }
 };
@@ -848,17 +763,13 @@ describe('[unit] Meraki Adapter Test', () => {
           assert.notEqual(undefined, sampleDotJson.properties.ssl.cert_file);
           assert.notEqual(undefined, sampleDotJson.properties.ssl.secure_protocol);
           assert.notEqual(undefined, sampleDotJson.properties.ssl.ciphers);
-
           assert.notEqual(undefined, sampleDotJson.properties.base_path);
           assert.notEqual(undefined, sampleDotJson.properties.version);
           assert.notEqual(undefined, sampleDotJson.properties.cache_location);
           assert.notEqual(undefined, sampleDotJson.properties.encode_pathvars);
+          assert.notEqual(undefined, sampleDotJson.properties.encode_queryvars);
           assert.notEqual(undefined, sampleDotJson.properties.save_metric);
           assert.notEqual(undefined, sampleDotJson.properties.protocol);
-          assert.notEqual(undefined, sampleDotJson.properties.stub);
-          assert.notEqual(undefined, sampleDotJson.properties.stub);
-          assert.notEqual(undefined, sampleDotJson.properties.stub);
-          assert.notEqual(undefined, sampleDotJson.properties.stub);
           assert.notEqual(undefined, sampleDotJson.properties.healthcheck);
           assert.notEqual(null, sampleDotJson.properties.healthcheck);
           assert.notEqual('', sampleDotJson.properties.healthcheck);
@@ -917,6 +828,12 @@ describe('[unit] Meraki Adapter Test', () => {
           assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.ca_file);
           assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.key_file);
           assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.cert_file);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getDevice);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getDevicesFiltered);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.isAlive);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getConfig);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getCount);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);

package/utils/entitiesToDB.js

@@ -14,10 +14,8 @@
  */
 
 const fs = require('fs');
-const { MongoClient } = require('mongodb');
 const path = require('path');
-// const { argv } = require('process');
-// const { string } = require('yargs');
+const utils = require('./tbUtils');
 
 // get the pronghorn database information
 const getPronghornProps = async (iapDir) => {
@@ -99,7 +97,7 @@ const optionsHandler = (options) => {
 /**
  *  Function used to put the adapter configuration into the provided database
  */
-const moveEntitiesToDB = (targetPath, options) => {
+const moveEntitiesToDB = async (targetPath, options) => {
   // set local variables
   let myOpts = options;
   let myPath = targetPath;
@@ -120,25 +118,7 @@ const moveEntitiesToDB = (targetPath, options) => {
   }
 
   // get the pronghorn database properties
-  optionsHandler(options).then((currentProps) => {
-    let mongoUrl;
-    let dbName;
-
-    // find the mongo properties so we can connect
-    if (currentProps.mongoProps) {
-      mongoUrl = currentProps.mongoProps.url;
-      dbName = currentProps.mongoProps.db;
-    } else if (currentProps.mongo) {
-      if (currentProps.mongo.url) {
-        mongoUrl = currentProps.mongo.url;
-      } else {
-        mongoUrl = `mongodb://${currentProps.mongo.host}:${currentProps.mongo.port}`;
-      }
-      dbName = currentProps.mongo.database;
-    } else {
-      throw new Error('Mongo properties are not specified in adapter preferences!');
-    }
-
+  return optionsHandler(options).then(async (currentProps) => {
     // Check valid filepath provided
     if (!myPath) {
       // if no path use the current directory without the utils
@@ -184,41 +164,16 @@ const moveEntitiesToDB = (targetPath, options) => {
     });
 
     // Upload documents to db collection
-    MongoClient.connect(mongoUrl, (err, db) => {
-      if (err) {
-        log.error(JSON.stringify(err));
-        throw err;
-      }
-
-      // get the proper collection
-      const collection = db.db(dbName).collection(myOpts.targetCollection);
-      // insert the documents into the collection
-      collection.insertMany(docs, { checkKeys: false }, (error, res) => {
-        if (error) {
-          log.error(JSON.stringify(error));
-          throw error;
-        }
-        // log the insertion, close the database and return
-        log.debug(`Inserted ${docs.length} documents to ${dbName}.${myOpts.targetCollection} with response ${JSON.stringify(res)}`);
-        db.close();
-        return res;
-      });
-    });
+    const iapDir = utils.getIAPHome();
+    const db = await utils.connect(iapDir, currentProps).catch((err) => { console.error(err); throw err; });
+    if (!db) {
+      console.error('Error occured when connectiong to database', currentProps);
+      throw new Error('Database not found');
+    }
+    const collection = db.collection(myOpts.targetCollection);
+    const res = await collection.insertMany(docs, { checkKeys: false }).catch((err) => { console.error(err); throw err; });
+    return res;
   });
 };
 
-// const args = process.argv.slice(2);
-
-// throw new SyntaxError(args[0]);
-
-// if (args.length === 0) {
-//   console.error('ERROR: target path not specified!');
-// } else if (args[0] === 'help') {
-//   log.trace('node ./entitiesToDB <target path> <options object: {iapDir: string, pronghornProps: string, targetCollection: string}>');
-// } else if (args.length === 1) {
-//   console.error('ERROR: IAP directory not specified');
-// } else {
-//   moveEntitiesToDB(args[0], args[1]);
-// }
-
 module.exports = { moveEntitiesToDB };

package/utils/tbScript.js

@@ -1,4 +1,4 @@
-/* eslint no-console: warn */
+/* eslint-disable no-console */
 /* eslint import/no-unresolved: warn */
 /* eslint global-require: warn */
 
@@ -7,7 +7,6 @@
 /* eslint import/no-extraneous-dependencies: warn */
 /* eslint import/no-dynamic-require: warn */
 
-const path = require('path');
 const program = require('commander');
 const rls = require('readline-sync');
 const utils = require('./tbUtils');
@@ -19,32 +18,39 @@ const { addAuthInfo } = require('./addAuth');
 
 const { troubleshoot, offline } = require('./troubleshootingAdapter');
 
-const main = async (command) => {
-  const dirname = utils.getDirname();
-  const iapDir = path.join(dirname, '../../../');
-  if (!utils.withinIAP(iapDir)) {
-    if (command === 'install') {
-      console.log('Not currently in IAP directory - installation not possible');
-      process.exit(0);
-    } else if (command === 'connectivity') {
+const executeInStandaloneMode = async (command) => {
+  console.info('\n> Executing the script outside of IAP installation directory');
+  console.info('> Using sampleProperties.json configuration');
+  switch (command) {
+    case 'install': {
+      console.error('Not currently in IAP directory - installation not possible');
+      break;
+    }
+    case 'connectivity': {
       const { host } = sampleProperties.properties;
       console.log(`perform networking diagnositics to ${host}`);
-      await utils.runConnectivity(host);
-      process.exit(0);
-    } else if (command === 'healthcheck') {
+      utils.runConnectivity(host);
+      break;
+    }
+    case 'healthcheck': {
       const a = basicGet.getAdapterInstance({ properties: sampleProperties });
       await utils.healthCheck(a);
-      process.exit(0);
-    } else if (command === 'basicget') {
-      await utils.runBasicGet();
-      process.exit(0);
+      break;
     }
-    if (rls.keyInYN('Troubleshooting without IAP?')) {
-      await offline();
+    case 'basicget': {
+      utils.runBasicGet();
+      break;
+    }
+    default: {
+      if (rls.keyInYN('Troubleshooting without IAP?')) {
+        await offline();
+      }
     }
-    process.exit(0);
   }
+  process.exit(0);
+};
 
+const executeUnderIAPInstallationDirectory = async (command) => {
   if (command === undefined) {
     await troubleshoot({}, true, true);
   } else if (command === 'install') {
@@ -79,6 +85,7 @@ const main = async (command) => {
         process.exit(0);
       }
     } else {
+      const dirname = utils.getCurrentExecutionPath();
       utils.verifyInstallationDir(dirname, name);
       utils.runTest();
       if (rls.keyInYN(`Do you want to install ${name} to IAP?`)) {
@@ -123,6 +130,14 @@ const main = async (command) => {
   }
 };
 
+const main = async (command) => {
+  if (!utils.areWeUnderIAPinstallationDirectory()) {
+    executeInStandaloneMode(command); // configuration from sampleproperties.json
+  } else {
+    executeUnderIAPInstallationDirectory(command); // configuration from $IAP_HOME/properties.json
+  }
+};
+
 program
   .command('connectivity')
   .alias('c')

package/utils/tbUtils.js

@@ -3,6 +3,7 @@
 /* eslint import/no-extraneous-dependencies: warn */
 /* eslint global-require: warn */
 /* eslint import/no-dynamic-require: warn */
+/* eslint-disable no-console */
 
 const path = require('path');
 const fs = require('fs-extra');
@@ -305,9 +306,9 @@ module.exports = {
    * @param {Object} sampleProperties - './sampleProperties.json' in adapter dir
    */
   createAdapter: function createAdapter(pronghornProps, profileItem, sampleProperties, adapterPronghorn) {
-    const dirname = this.getDirname();
-    const packagePath = `${dirname.split('node_modules')[0]}package.json`;
-    const info = JSON.parse(fs.readFileSync(packagePath));
+    const iapDir = this.getIAPHome();
+    const packageFile = path.join(iapDir, 'package.json');
+    const info = JSON.parse(fs.readFileSync(packageFile));
     const version = parseInt(info.version.split('.')[0], 10);
 
     let adapter = {};
@@ -399,52 +400,42 @@ module.exports = {
   },
 
   /**
-   * @summary Check whether adapter is located within IAP node_modules
-   *          by loading properties.json. If not, return false.
-   * @function withinIAP
-   * @param {String} iapDir root directory of IAP
+   * @summary Obtain the IAP installation directory depending on how adapter is used:
+   * by IAP, or by npm run CLI interface
+   * @returns IAP installation directory or null if adapter running without IAP
+   * @function getIAPHome
    */
-  withinIAP: (iapDir) => {
-    try {
-      const rawProps = require(path.join(iapDir, 'properties.json'));
-      return rawProps;
-    } catch (error) {
-      return false;
+  getIAPHome: function getIAPHome() {
+    let IAPHomePath = null;
+    // check if adapter started via IAP, use path injected by core
+    if (process.env.iap_home) IAPHomePath = process.env.iap_home;
+    // check if adapter started via CLI `npm run <command>` so we have to be located under
+    // <IAP_HOME>/node_modules/@itentialopensource/<adapter_name>/ directory
+    const currentExecutionPath = this.getCurrentExecutionPath();
+    if (currentExecutionPath.indexOf('/node_modules') >= 0) {
+      [IAPHomePath] = currentExecutionPath.split('/node_modules');
     }
+    return IAPHomePath;
   },
 
   /**
-   * @summary Used to determine the proper dirname to return in case adapter reference is
-   * symlinked withink IAP
-   * @returns the symlinked path (using pwd command) of the adapter in case properties.json
-   * is not found in the original path
-   * @function getDirname
+   * @summary get current execution path without resolving symbolic links,
+   * use `pwd` command wihout '-P' option (resolving symlinks) https://linux.die.net/man/1/pwd
+   * @returns
+   * @function getCurrentExecutionPAth
    */
-  getDirname: function getDirname() {
-    if (this.withinIAP(path.join(__dirname, '../../../../'))) {
-      return __dirname;
-    }
+  getCurrentExecutionPath: function getCurrentExecutionPAth() {
     const { stdout } = this.systemSync('pwd', true);
     return stdout.trim();
   },
 
   /**
-   * @summary Obtain the IAP installation directory depending on how adapter is used:
-   * by IAP, or by npm run CLI interface
-   * @returns IAP installation directory
-   * @function getIAPHome
+   * @summary checks if command executed from <IAP_HOME>/node_modules/@itentialopensource/<adapter_name>/ location
+   * @returns true if command executed under <IAP_HOME>/node_modules/@itentialopensource/<adapter_name>/ path
+   * @function areWeUnderIAPinstallationDirectory
    */
-  getIAPHome: function getIAPHome() {
-    // if adapter started via IAP, use path injected by core
-    if (process.env.iap_home) return process.env.iap_home;
-    // adapter started via CLI `npm run <command>` so we have to be located under
-    // <IAP_HOME>/node_modules/@itentialopensource/<adapter>/ directory,
-    // use `pwd` command wihout option -P(resolving symlinks) https://linux.die.net/man/1/pwd
-    const { stdout } = this.systemSync('pwd', true);
-    if (stdout.indexOf('/node_modules') >= 0) {
-      return stdout.trim().split('/node_modules')[0];
-    }
-    return path.join(stdout.trim(), '../../../');
+  areWeUnderIAPinstallationDirectory: function areWeUnderIAPinstallationDirectory() {
+    return path.join(this.getCurrentExecutionPath(), '../../..') === this.getIAPHome();
   },
 
   /**
@@ -454,9 +445,23 @@ module.exports = {
    * @param {Object} properties - pronghornProps
    */
   connect: async function connect(iapDir, properties) {
-    // Connect to Mongo
+    let dbConnectionProperties = {};
+    if (properties.mongoProps) {
+      dbConnectionProperties = properties.mongoProps;
+    } else if (properties.mongo) {
+      if (properties.mongo.url) {
+        dbConnectionProperties.url = properties.mongo.url;
+      } else {
+        dbConnectionProperties.url = `mongodb://${properties.mongo.host}:${properties.mongo.port}`;
+      }
+      dbConnectionProperties.db = properties.mongo.database;
+    }
+    if (!dbConnectionProperties.url || !dbConnectionProperties.db) {
+      throw new Error('Mongo properties are not specified in IAP configuration!');
+    }
+
     const { MongoDBConnection } = require(path.join(iapDir, 'node_modules/@itential/database'));
-    const connection = new MongoDBConnection(properties.mongoProps);
+    const connection = new MongoDBConnection(dbConnectionProperties);
     const database = await connection.connect(true);
     return database;
   }

package/utils/testRunner.js

@@ -47,11 +47,11 @@ function replaceTestVars(test) {
   let intTest = fs.readFileSync(test, 'utf8');
 
   // replace stub variable but check if it exists first
-  let sindex = intTest.indexOf('const stub');
+  let sindex = intTest.indexOf('samProps.stub');
   let eindex = intTest.indexOf(';', sindex);
   let replStr = intTest.substring(sindex, eindex + 1);
   if (sindex > -1) {
-    intTest = intTest.replace(replStr, `const stub = ${stub};`);
+    intTest = intTest.replace(replStr, `samProps.stub = ${stub};`);
   }
 
   // replace isRapidFail variable but check if it exists first
@@ -71,46 +71,46 @@ function replaceTestVars(test) {
   }
 
   // replace host variable
-  sindex = intTest.indexOf('const host');
+  sindex = intTest.indexOf('samProps.host');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const host = '${host}';`);
+  intTest = intTest.replace(replStr, `samProps.host = '${host}';`);
 
   // replace username variable
-  sindex = intTest.indexOf('const username');
+  sindex = intTest.indexOf('samProps.authentication.username');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const username = '${username}';`);
+  intTest = intTest.replace(replStr, `samProps.authentication.username = '${username}';`);
 
   // replace password variable
-  sindex = intTest.indexOf('const password');
+  sindex = intTest.indexOf('samProps.authentication.password');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const password = '${password}';`);
+  intTest = intTest.replace(replStr, `samProps.authentication.password = '${password}';`);
 
   // replace protocol variable
-  sindex = intTest.indexOf('const protocol');
+  sindex = intTest.indexOf('samProps.protocol');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const protocol = '${protocol}';`);
+  intTest = intTest.replace(replStr, `samProps.protocol = '${protocol}';`);
 
   // replace port variable
-  sindex = intTest.indexOf('const port');
+  sindex = intTest.indexOf('samProps.port');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const port = ${port};`);
+  intTest = intTest.replace(replStr, `samProps.port = ${port};`);
 
   // replace sslenable variable
-  sindex = intTest.indexOf('const sslenable');
+  sindex = intTest.indexOf('samProps.ssl.enabled');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const sslenable = ${sslenable};`);
+  intTest = intTest.replace(replStr, `samProps.ssl.enabled = ${sslenable};`);
 
   // replace sslinvalid variable
-  sindex = intTest.indexOf('const sslinvalid');
+  sindex = intTest.indexOf('samProps.ssl.accept_invalid_cert');
   eindex = intTest.indexOf(';', sindex);
   replStr = intTest.substring(sindex, eindex + 1);
-  intTest = intTest.replace(replStr, `const sslinvalid = ${sslinvalid};`);
+  intTest = intTest.replace(replStr, `samProps.ssl.accept_invalid_cert = ${sslinvalid};`);
 
   console.log(`Updates to ${test} complete`);
   fs.writeFileSync(test, intTest);