@itentialopensource/adapter-netbox_v33 0.1.1

package/utils/testRunner.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+/* @copyright Itential, LLC 2019 */
+
+const fs = require('fs-extra');
+const rl = require('readline-sync');
+const execute = require('child_process').exec;
+
+/**
+ * This script will determine the type of integration test to run
+ * based on input. If other information is needed, it will solicit
+ * that input and then edit the integration test accordingly.
+ */
+
+let stub = true;
+let isRapidFail = false;
+let isSaveMockData = false;
+let host = 'replace.hostorip.here';
+let username = 'username';
+let password = 'password';
+let protocol = 'http';
+let port = 80;
+let sslenable = false;
+let sslinvalid = false;
+const dstub = true;
+const disRapidFail = false;
+const disSaveMockData = false;
+const dhost = 'replace.hostorip.here';
+const dusername = 'username';
+const dpassword = 'password';
+const dprotocol = 'http';
+const dport = 80;
+const dsslenable = false;
+const dsslinvalid = false;
+
+let stderror = false;
+let running = false;
+
+/**
+ * Updates the integration test file with the proper vars
+ */
+function replaceTestVars(test) {
+  if (!fs.existsSync(test)) {
+    console.log(`Could not find ${test}`);
+    return 'error';
+  }
+
+  let intTest = fs.readFileSync(test, 'utf8');
+
+  // replace stub variable but check if it exists first
+  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, `samProps.stub = ${stub};`);
+  }
+
+  // replace isRapidFail variable but check if it exists first
+  sindex = intTest.indexOf('const isRapidFail');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  if (sindex > -1) {
+    intTest = intTest.replace(replStr, `const isRapidFail = ${isRapidFail};`);
+  }
+
+  // replace isSaveMockData variable but check if it exists first
+  sindex = intTest.indexOf('const isSaveMockData');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  if (sindex > -1) {
+    intTest = intTest.replace(replStr, `const isSaveMockData = ${isSaveMockData};`);
+  }
+
+  // replace host variable
+  sindex = intTest.indexOf('samProps.host');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.host = '${host}';`);
+
+  // replace username variable
+  sindex = intTest.indexOf('samProps.authentication.username');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.authentication.username = '${username}';`);
+
+  // replace password variable
+  sindex = intTest.indexOf('samProps.authentication.password');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.authentication.password = '${password}';`);
+
+  // replace protocol variable
+  sindex = intTest.indexOf('samProps.protocol');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.protocol = '${protocol}';`);
+
+  // replace port variable
+  sindex = intTest.indexOf('samProps.port');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.port = ${port};`);
+
+  // replace sslenable variable
+  sindex = intTest.indexOf('samProps.ssl.enabled');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.ssl.enabled = ${sslenable};`);
+
+  // replace sslinvalid variable
+  sindex = intTest.indexOf('samProps.ssl.accept_invalid_cert');
+  eindex = intTest.indexOf(';', sindex);
+  replStr = intTest.substring(sindex, eindex + 1);
+  intTest = intTest.replace(replStr, `samProps.ssl.accept_invalid_cert = ${sslinvalid};`);
+
+  console.log(`Updates to ${test} complete`);
+  fs.writeFileSync(test, intTest);
+  return 'success';
+}
+
+/**
+ * Updates the integration test file and runs the script
+ */
+function runTest(callback) {
+  replaceTestVars('test/integration/adapterTestIntegration.js');
+
+  let cmdPath = 'npm run test:integration';
+  console.log('\nRUNNING INTEGRATION TESTS - THIS WILL TAKE SOME TIME AND WILL NOT PRINT UNTIL TEST IS COMPLETE!\n');
+  if (stderror) {
+    console.log('\nNOTE: standard error from tests is included - unless test failed, these may be expected errors:\n');
+    cmdPath += ' 2>&1';
+  } else {
+    console.log('stderr not shown');
+  }
+
+  return execute(cmdPath, (cerror, stdout) => {
+    console.log('executed tests:\n');
+    console.log(`${stdout}\n`);
+    if (cerror) {
+      console.log('\x1b[31m%s\x1b[0m', '\nexec error:\n');
+      console.log('\x1b[31m%s\x1b[0m', `${cerror}\n`);
+    }
+    // reset the defaults
+    stub = dstub;
+    isRapidFail = disRapidFail;
+    isSaveMockData = disSaveMockData;
+    host = dhost;
+    username = dusername;
+    password = dpassword;
+    protocol = dprotocol;
+    port = dport;
+    sslenable = dsslenable;
+    sslinvalid = dsslinvalid;
+    replaceTestVars('test/integration/adapterTestIntegration.js');
+    return callback('done');
+  });
+}
+
+/**
+ * Updates the unit test file and runs the script
+ */
+function runUnitTest(callback) {
+  let cmdPath = 'npm run test:unit';
+  console.log('\nRUNNING UNIT TESTS - THIS WILL TAKE SOME TIME AND WILL NOT PRINT UNTIL TEST IS COMPLETE!\n');
+
+  if (stderror) {
+    console.log('\nNOTE: standard error from tests is included- unless test failed, these may be expected errors:\n');
+    cmdPath += ' 2>&1';
+  } else {
+    console.log('stderr not shown');
+  }
+
+  return execute(cmdPath, (cerror, stdout) => {
+    console.log('executed tests:\n');
+    console.log(`${stdout}\n`);
+
+    if (cerror) {
+      console.log('\x1b[31m%s\x1b[0m', '\nexec error:\n');
+      console.log('\x1b[31m%s\x1b[0m', `${cerror}\n`);
+    }
+
+    return callback('done');
+  });
+}
+
+// print process.argv
+const args = process.argv.slice(2);
+
+// go through the arguments that where provided
+for (let a = 0; a < args.length; a += 1) {
+  if (args[a].toUpperCase() === '-H' || args[a].toUpperCase() === '--HELP') {
+    let message = '\nThis tool is used to make it easier to run integration tests.\n';
+    message += '\n';
+    message += 'Options:\n';
+    message += '-h, --help: Prints this message\n';
+    message += '-f, --failfast: Fail the test when the first test fails\n';
+    message += '-m, --mockdata: Update mock data files with the results from testing (only if running integrated)\n';
+    message += '-r, --reset: Resets the variables back to stub settings and removes credentials\n';
+    message += '-s, --stderror: Displays the standard error from the run, this can have data even if all the tests pass\n';
+    message += '-u, --unit: Runs just the unit tests as well\n';
+    console.log(message);
+    running = true;
+  }
+
+  if (args[a].toUpperCase() === '-F' || args[a].toUpperCase() === '--FAILFAST') {
+    isRapidFail = true;
+  }
+  if (args[a].toUpperCase() === '-M' || args[a].toUpperCase() === '--MOCKDATA') {
+    isSaveMockData = true;
+  }
+  if (args[a].toUpperCase() === '-R' || args[a].toUpperCase() === '--RESET') {
+    running = true;
+    replaceTestVars('test/integration/adapterTestIntegration.js');
+    replaceTestVars('test/unit/adapterTestUnit.js');
+    console.log('test reset complete');
+  }
+  if (args[a].toUpperCase() === '-S' || args[a].toUpperCase() === '--STDERROR') {
+    stderror = true;
+  }
+  if (args[a].toUpperCase() === '-U' || args[a].toUpperCase() === '--UNIT') {
+    running = true;
+    runUnitTest((status) => {
+      console.log(status);
+      process.exit(1);
+    });
+  }
+}
+
+if (!running) {
+  // how are we running the test?
+  let answer = rl.question('\nDo you want to run the integration test integrated with the other system? (no): ');
+  if (answer && (answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y')) {
+    stub = false;
+    console.log('Need more information about the integration!');
+  } else {
+    running = true;
+    runTest((status) => {
+      console.log(status);
+      process.exit(1);
+    });
+  }
+
+  if (!running) {
+    // how are we running the test?
+    answer = rl.question('\nWhat is the dns or ip of the system you want to test with? (localhost): ');
+    if (answer) {
+      host = answer;
+    } else {
+      host = 'localhost';
+    }
+
+    // need the username to authenticate with
+    answer = rl.question('\nWhat is the username to authenticate, if no authentication just return? (username): ');
+    if (answer) {
+      username = answer;
+    }
+
+    // need the password to authenticate with
+    answer = rl.question('\nWhat is the password to authenticate, if no authentication just return? (password): ', { hideEchoBack: true });
+    if (answer) {
+      password = answer;
+    }
+
+    // need the protocol used with other system
+    answer = rl.question('\nWhat is the protocol used to communicate with the system? (http): ');
+    if (answer) {
+      protocol = answer;
+    }
+
+    if (protocol === 'https') {
+      // if protocol is https, set default port to 443
+      port = 443;
+      // need the port used with other system
+      answer = rl.question('\nWhat is the port used to communicate with the system? (443): ');
+      port = 443; // update default answer to 443 for https
+      if (answer) {
+        port = Number(answer);
+      }
+
+      // turn on ssl and accept invalid certs
+      sslenable = true;
+      sslinvalid = true;
+      runTest((status) => {
+        console.log(status);
+        process.exit(1);
+      });
+    } else {
+      // need the port used with other system
+      answer = rl.question('\nWhat is the port used to communicate with the system? (80): ');
+      if (answer) {
+        port = Number(answer);
+      }
+      runTest((status) => {
+        console.log(status);
+        process.exit(1);
+      });
+    }
+  }
+}

package/utils/troubleshootingAdapter.js

@@ -0,0 +1,195 @@
+/* @copyright Itential, LLC 2020 */
+/* eslint global-require: warn */
+/* eslint no-console: warn */
+/* eslint import/no-unresolved: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const path = require('path');
+const rls = require('readline-sync');
+const fs = require('fs-extra');
+
+const utils = require(path.join(__dirname, 'tbUtils'));
+const basicGet = require(path.join(__dirname, 'basicGet'));
+const { name } = require(path.join(__dirname, '..', 'package.json'));
+const sampleProperties = require(path.join(__dirname, '..', 'sampleProperties.json'));
+
+// send interactive questions and collection answers
+// return updated connection object
+const collectAnswersSync = (questions, props) => {
+  const answers = [];
+  questions.forEach((q) => {
+    const answer = rls.question(q);
+    answers.push(answer);
+  });
+  return utils.getNewProps(answers, props);
+};
+
+// change object into array of questions
+const confirm = (props) => {
+  const questions = Object.keys(props).map((key) => `${key}: (${props[key]}) `);
+  return collectAnswersSync(questions, props);
+};
+
+// allow user to change auth_method
+const confirmAuthOptions = (authentication) => {
+  const authOptions = ['basic user_password', 'request_token', 'static_token', 'no_authentication'];
+  const displayAuthOptions = utils.getDisplayAuthOptions(authentication.auth_method, authOptions);
+  const index = rls.keyInSelect(displayAuthOptions, 'Which authentication?');
+  if (index === -1) {
+    return authentication.auth_method;
+  }
+  console.log(`${authOptions[index]} is selected.`);
+  return authOptions[index];
+};
+
+// helper function to update auth properties
+const confirmAndUpdate = (auth, config) => {
+  const newAuth = confirm(auth);
+  return utils.updateAuth(newAuth, auth, config);
+};
+
+// extract basic auth properties
+const updateBasicAuth = (config, authentication) => {
+  const auth = {
+    username: authentication.username,
+    password: authentication.password
+  };
+  return confirmAndUpdate(auth, config);
+};
+
+// extract static auth properties
+const updateStaticAuth = (config, authentication) => {
+  const auth = {
+    token: authentication.token,
+    auth_field: authentication.auth_field,
+    auth_field_format: authentication.auth_field_format
+  };
+  return confirmAndUpdate(auth, config);
+};
+
+// troubleshooting connection and healthcheck endpoint setting of adapter
+const VerifyHealthCheckEndpoint = (serviceItem, props, scriptFlag) => {
+  // Updates connectivity params and runs connectivity
+  let connConfig;
+  const result = {};
+  if (scriptFlag) {
+    const connection = utils.getConnection(serviceItem.properties);
+    const newConnection = confirm(connection);
+    utils.runConnectivity(newConnection.host, scriptFlag);
+    connConfig = utils.updateNewConnection(serviceItem, newConnection);
+  } else {
+    let { properties: { properties: { host } } } = serviceItem;
+    if (props.connProps) {
+      connConfig = utils.updateNewConnection(serviceItem, props.connProps);
+      host = connConfig.properties.properties.host;
+    } else {
+      connConfig = serviceItem;
+    }
+    result.connectivity = utils.runConnectivity(host, scriptFlag);
+  }
+  // Updates the healthcheck endpoing
+  const healthcheck = require('../entities/.system/action.json');
+  const healthCheckEndpoint = utils.getHealthCheckEndpoint(healthcheck);
+  let newHealthCheckEndpoint = healthCheckEndpoint;
+  if (scriptFlag) {
+    newHealthCheckEndpoint = confirm(healthCheckEndpoint);
+    utils.getHealthCheckEndpointURL(newHealthCheckEndpoint, connConfig);
+  } else if (props.healthCheckEndpoint) {
+    newHealthCheckEndpoint = props.healthCheckEndpoint;
+  }
+  // Updates the authorization params
+  const { authentication } = connConfig.properties.properties;
+  let updatedAdapter = connConfig;
+  if (scriptFlag) {
+    authentication.auth_method = confirmAuthOptions(authentication);
+    if (authentication.auth_method === 'basic user_password') {
+      updatedAdapter = updateBasicAuth(connConfig, authentication);
+    } else if (authentication.auth_method === 'static_token') {
+      updatedAdapter = updateStaticAuth(connConfig, authentication);
+    } else if (authentication.auth_method === 'request_token') {
+      console.log('current troubleshooting script does not support updating request_token authentication');
+    }
+  } else if (props.auth) {
+    updatedAdapter = utils.updateAuth(props.auth, authentication, connConfig);
+  }
+  // Writes the new healthcheck endpoint into action.json
+  utils.updateHealthCheckEndpoint(newHealthCheckEndpoint, healthCheckEndpoint, healthcheck);
+  return { result, updatedAdapter };
+};
+
+const offline = async () => {
+  console.log('Start offline troubleshooting');
+  const { updatedAdapter } = VerifyHealthCheckEndpoint({ properties: sampleProperties }, {}, true);
+  const a = basicGet.getAdapterInstance(updatedAdapter);
+  const res = await utils.healthCheck(a);
+  if (!res) {
+    console.log('run `npm run troubleshoot` again to update settings');
+    process.exit(0);
+  }
+  console.log('Save changes to sampleProperties.json');
+  await fs.writeFile('sampleProperties.json', JSON.stringify(updatedAdapter.properties, null, 2));
+  if (rls.keyInYN('Test with more GET request')) {
+    await utils.runBasicGet(true);
+  }
+};
+
+const troubleshoot = async (props, scriptFlag, persistFlag, adapter) => {
+  let serviceItem;
+  if (adapter && adapter.allProps) {
+    serviceItem = { properties: { properties: adapter.allProps } };
+  }
+  if (adapter && adapter.properties && adapter.properties.properties) {
+    serviceItem = adapter.properties;
+  }
+  if (serviceItem) {
+    if (!scriptFlag || rls.keyInYN(`Start verifying the connection and authentication properties for ${name}?`)) {
+      const { result, updatedAdapter } = VerifyHealthCheckEndpoint(serviceItem, props, scriptFlag);
+      let a;
+      if (scriptFlag) {
+        a = basicGet.getAdapterInstance(updatedAdapter);
+      } else {
+        a = adapter;
+      }
+      const healthRes = await utils.healthCheck(a);
+      result.healthCheck = healthRes;
+      if (scriptFlag && !healthRes) {
+        console.log('run `npm run troubleshoot` again to update settings');
+        process.exit(0);
+      }
+
+      if (persistFlag && healthRes) {
+        const { database } = await utils.getIAPDatabaseConnection();
+        const update = { $set: { properties: updatedAdapter.properties } };
+        await database.collection(utils.SERVICE_CONFIGS_COLLECTION).updateOne(
+          { model: name }, update
+        );
+        if (scriptFlag) {
+          console.log(`${name} updated.`);
+        }
+      }
+      if (scriptFlag) {
+        if (rls.keyInYN('Test with more GET request')) {
+          await utils.runBasicGet(scriptFlag);
+          process.exit(0);
+        } else {
+          console.log('Exiting');
+          process.exit(0);
+        }
+      } else {
+        result.basicGet = await utils.runBasicGet(scriptFlag);
+        return result;
+      }
+    } else {
+      console.log('You can update healthCheckEndpoint in ./entities/.system/action.json');
+      console.log('You can update authentication credientials under Settings/Services');
+      console.log('Exiting');
+      process.exit(0);
+    }
+  } else {
+    console.log(`${name} not installed`);
+    console.log('run `npm run install:adapter` to install current adapter to IAP first. Exiting...');
+  }
+  return null;
+};
+
+module.exports = { troubleshoot, offline };

package/workflows/README.md

@@ -0,0 +1,3 @@
+# Adapter Workflows
+
+This directory contains workflows that support the adapter use cases. These workflows can be imported into IAP. If the adapter is installed using App-Artifact the workflows should be automatically imported.