@itentialopensource/adapter-aruba_airwave 0.2.1 → 0.3.0

package/test/unit/adapterBaseTestUnit.js

@@ -5,9 +5,9 @@
 
 // include required items for testing & logging
 const assert = require('assert');
+const path = require('path');
 const fs = require('fs-extra');
 const mocha = require('mocha');
-const path = require('path');
 const winston = require('winston');
 const { expect } = require('chai');
 const { use } = require('chai');
@@ -60,11 +60,16 @@ global.pronghornProps = {
           token_timeout: -1,
           token_cache: 'local',
           auth_field: 'header.headers.Authorization',
-          auth_field_format: 'Basic {b64}{username}:{password}{/b64}'
+          auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
+          auth_logging: false,
+          client_id: '',
+          client_secret: '',
+          grant_type: ''
         },
         healthcheck: {
           type: 'none',
-          frequency: 60000
+          frequency: 60000,
+          query_object: {}
         },
         throttle: {
           throttle_enabled: false,
@@ -95,13 +100,16 @@ global.pronghornProps = {
           },
           healthcheck_on_timeout: true,
           return_raw: true,
-          archiving: false
+          archiving: false,
+          return_request: false
         },
         proxy: {
           enabled: false,
           host: '',
           port: 1,
-          protocol: 'http'
+          protocol: 'http',
+          username: '',
+          password: ''
         },
         ssl: {
           ecdhCurve: '',
@@ -297,90 +305,73 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#getAllFunctions', () => {
-      it('should have a getAllFunctions function', (done) => {
+    describe('#connect', () => {
+      it('should have a connect function', (done) => {
         try {
-          assert.equal(true, typeof a.getAllFunctions === 'function');
+          assert.equal(true, typeof a.connect === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should return a list of functions', (done) => {
-        const returnedFunctions = ['addEntityCache', 'capabilityResults', 'checkActionFiles', 'checkProperties', 'connect', 'encryptProperty',
-          'entityInList', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck',
-          'refreshProperties', 'runBasicGet', 'runConnectivity', 'runHealthcheck', 'suspend', 'troubleshoot', 'unsuspend', 'updateAdapterConfiguration', 'addListener',
-          'emit', 'eventNames', 'getMaxListeners', 'listenerCount', 'listeners', 'off', 'on', 'once', 'prependListener',
-          'prependOnceListener', 'rawListeners', 'removeAllListeners', 'removeListener', 'setMaxListeners'];
+      it('should get connected - no healthcheck', (done) => {
         try {
-          const expectedFunctions = a.getAllFunctions();
+          a.healthcheckType = 'none';
+          a.connect();
+
           try {
-            assert.equal(JSON.stringify(expectedFunctions), JSON.stringify(returnedFunctions));
+            assert.equal(true, a.alive);
             done();
-          } catch (err) {
-            log.error(`Test Failure: ${err}`);
-            done(err);
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
           }
         } catch (error) {
           log.error(`Adapter Exception: ${error}`);
           done(error);
         }
-      }).timeout(attemptTimeout);
-    });
-
-    describe('#getWorkflowFunctions', () => {
-      it('should have a getWorkflowFunctions function', (done) => {
-        try {
-          assert.equal(true, typeof a.getWorkflowFunctions === 'function');
-          done();
-        } catch (error) {
-          log.error(`Test Failure: ${error}`);
-          done(error);
-        }
       });
-      it('should retrieve workflow functions', (done) => {
+      it('should get connected - startup healthcheck', (done) => {
         try {
-          const expectedFunctions = a.getWorkflowFunctions([]);
+          a.healthcheckType = 'startup';
+          a.connect();
+
           try {
-            assert.equal(0, expectedFunctions.length);
+            assert.equal(true, a.alive);
             done();
-          } catch (err) {
-            log.error(`Test Failure: ${err}`);
-            done(err);
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
           }
         } catch (error) {
           log.error(`Adapter Exception: ${error}`);
           done(error);
         }
-      }).timeout(attemptTimeout);
+      });
     });
 
-    describe('#checkProperties', () => {
-      it('should have a checkProperties function', (done) => {
+    describe('#healthCheck', () => {
+      it('should have a healthCheck function', (done) => {
         try {
-          assert.equal(true, typeof a.checkProperties === 'function');
+          assert.equal(true, typeof a.healthCheck === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('the sample properties should be good - if failure change the log level', (done) => {
+      it('should be healthy', (done) => {
         try {
-          const samplePropsJson = require('../../sampleProperties.json');
-          const clean = a.checkProperties(samplePropsJson.properties);
-          try {
-            assert.notEqual(0, Object.keys(clean));
-            assert.equal(undefined, clean.exception);
-            assert.notEqual(undefined, clean.host);
-            assert.notEqual(null, clean.host);
-            assert.notEqual('', clean.host);
-            done();
-          } catch (err) {
-            log.error(`Test Failure: ${err}`);
-            done(err);
-          }
+          a.healthCheck(null, (data) => {
+            try {
+              assert.equal(true, a.healthy);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
         } catch (error) {
           log.error(`Adapter Exception: ${error}`);
           done(error);
@@ -388,24 +379,28 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#checkActionFiles', () => {
-      it('should have a checkActionFiles function', (done) => {
+    describe('#getAllFunctions', () => {
+      it('should have a getAllFunctions function', (done) => {
         try {
-          assert.equal(true, typeof a.checkActionFiles === 'function');
+          assert.equal(true, typeof a.getAllFunctions === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('the action files should be good - if failure change the log level as most issues are warnings', (done) => {
+      it('should return a list of functions', (done) => {
+        const returnedFunctions = ['checkActionFiles', 'checkProperties', 'connect', 'encryptProperty', 'genericAdapterRequest', 'genericAdapterRequestNoBasePath',
+          'getAllFunctions', 'getConfig', 'getConfigAuth', 'getDevice', 'getDeviceAuth', 'getDevicesFiltered', 'getDevicesFilteredAuth', 'hasEntities', 'hasEntitiesAuth',
+          'healthCheck', 'iapActivateTasks', 'iapDeactivateTasks', 'iapExpandedGenericAdapterRequest', 'iapFindAdapterPath', 'iapGetAdapterInventory', 'iapGetAdapterQueue',
+          'iapGetAdapterWorkflowFunctions', 'iapGetDeviceCount', 'iapGetDeviceCountAuth', 'iapMoveAdapterEntitiesToDB', 'iapPopulateEntityCache', 'iapRetrieveEntitiesCache',
+          'iapRunAdapterBasicGet', 'iapRunAdapterConnectivity', 'iapRunAdapterHealthcheck', 'iapRunAdapterLint', 'iapRunAdapterTests', 'iapSuspendAdapter', 'iapTroubleshootAdapter',
+          'iapUnsuspendAdapter', 'iapUpdateAdapterConfiguration', 'isAlive', 'isAliveAuth', 'refreshProperties', 'addListener', 'emit', 'eventNames', 'getMaxListeners',
+          'listenerCount', 'listeners', 'off', 'on', 'once', 'prependListener', 'prependOnceListener', 'rawListeners', 'removeAllListeners', 'removeListener', 'setMaxListeners'];
         try {
-          const clean = a.checkActionFiles();
+          const expectedFunctions = a.getAllFunctions();
           try {
-            for (let c = 0; c < clean.length; c += 1) {
-              log.error(clean[c]);
-            }
-            assert.equal(0, clean.length);
+            assert.equal(JSON.stringify(expectedFunctions), JSON.stringify(returnedFunctions));
             done();
           } catch (err) {
             log.error(`Test Failure: ${err}`);
@@ -418,19 +413,19 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#getQueue', () => {
-      it('should have a getQueue function', (done) => {
+    describe('#iapGetAdapterWorkflowFunctions', () => {
+      it('should have a iapGetAdapterWorkflowFunctions function', (done) => {
         try {
-          assert.equal(true, typeof a.getQueue === 'function');
+          assert.equal(true, typeof a.iapGetAdapterWorkflowFunctions === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should get information for all of the requests currently in the queue', (done) => {
+      it('should retrieve workflow functions', (done) => {
         try {
-          const expectedFunctions = a.getQueue();
+          const expectedFunctions = a.iapGetAdapterWorkflowFunctions([]);
           try {
             assert.equal(0, expectedFunctions.length);
             done();
@@ -445,73 +440,61 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#connect', () => {
-      it('should have a connect function', (done) => {
+    describe('#checkActionFiles', () => {
+      it('should have a checkActionFiles function', (done) => {
         try {
-          assert.equal(true, typeof a.connect === 'function');
+          assert.equal(true, typeof a.checkActionFiles === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should get connected - no healthcheck', (done) => {
-        try {
-          a.healthcheckType = 'none';
-          a.connect();
-
-          try {
-            assert.equal(true, a.alive);
-            done();
-          } catch (error) {
-            log.error(`Test Failure: ${error}`);
-            done(error);
-          }
-        } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
-          done(error);
-        }
-      });
-      it('should get connected - startup healthcheck', (done) => {
+      it('the action files should be good - if failure change the log level as most issues are warnings', (done) => {
         try {
-          a.healthcheckType = 'startup';
-          a.connect();
-
+          const clean = a.checkActionFiles();
           try {
-            assert.equal(true, a.alive);
+            for (let c = 0; c < clean.length; c += 1) {
+              log.error(clean[c]);
+            }
+            assert.equal(0, clean.length);
             done();
-          } catch (error) {
-            log.error(`Test Failure: ${error}`);
-            done(error);
+          } catch (err) {
+            log.error(`Test Failure: ${err}`);
+            done(err);
           }
         } catch (error) {
           log.error(`Adapter Exception: ${error}`);
           done(error);
         }
-      });
+      }).timeout(attemptTimeout);
     });
 
-    describe('#healthCheck', () => {
-      it('should have a healthCheck function', (done) => {
+    describe('#checkProperties', () => {
+      it('should have a checkProperties function', (done) => {
         try {
-          assert.equal(true, typeof a.healthCheck === 'function');
+          assert.equal(true, typeof a.checkProperties === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should be healthy', (done) => {
+      it('the sample properties should be good - if failure change the log level', (done) => {
         try {
-          a.healthCheck(null, (data) => {
-            try {
-              assert.equal(true, a.healthy);
-              done();
-            } catch (err) {
-              log.error(`Test Failure: ${err}`);
-              done(err);
-            }
-          });
+          const samplePropsJson = require('../../sampleProperties.json');
+          const clean = a.checkProperties(samplePropsJson.properties);
+          try {
+            assert.notEqual(0, Object.keys(clean));
+            assert.equal(undefined, clean.exception);
+            assert.notEqual(undefined, clean.host);
+            assert.notEqual(null, clean.host);
+            assert.notEqual('', clean.host);
+            done();
+          } catch (err) {
+            log.error(`Test Failure: ${err}`);
+            done(err);
+          }
         } catch (error) {
           log.error(`Adapter Exception: ${error}`);
           done(error);
@@ -573,33 +556,21 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    const entityType = 'mockType';
-    const entities = {
-      response: [
-        {
-          name: 'Godric Gryffindor'
-        }, {
-          name: 'Salazar Slytherin'
-        }
-      ]
-    };
-    const key = 'name';
-    describe('#addEntityCache', () => {
-      it('should have a addEntityCache function', (done) => {
+    describe('#iapUpdateAdapterConfiguration', () => {
+      it('should have a iapUpdateAdapterConfiguration function', (done) => {
         try {
-          assert.equal(true, typeof a.addEntityCache === 'function');
+          assert.equal(true, typeof a.iapUpdateAdapterConfiguration === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should take the entities and add them to the cache', (done) => {
-        // Run the promise and verify the results match what we were expecting.
+      it('should return no updated if no changes are provided', (done) => {
         try {
-          a.addEntityCache(entityType, entities, key, (data, error) => {
+          a.iapUpdateAdapterConfiguration(null, null, null, null, null, null, (data, error) => {
             try {
-              assert.equal(true, data);
+              assert.equal('No configuration updates to make', data.response);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -611,87 +582,12 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-    });
-
-    const cache = [
-      'Godric Gryffindor',
-      'Salazar Slytherin'
-    ];
-    describe('#entityInList', () => {
-      it('should have a entityInList function', (done) => {
-        try {
-          assert.equal(true, typeof a.entityInList === 'function');
-          done();
-        } catch (error) {
-          log.error(`Test Failure: ${error}`);
-          done(error);
-        }
-      });
-      it('should return true if the entity is in the list of entities for this adapter', (done) => {
-        try {
-          const entityExist = a.entityInList('Godric Gryffindor', cache);
-          try {
-            assert.equal(true, entityExist[0]);
-            done();
-          } catch (err) {
-            log.error(`Test Failure: ${err}`);
-            done(err);
-          }
-        } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
-          done(error);
-        }
-      }).timeout(attemptTimeout);
-      it('should return false if the entity is not in the list of entities for this adapter', (done) => {
-        try {
-          const entityExist = a.entityInList('XXXX', cache);
-          try {
-            assert.equal(false, entityExist[0]);
-            done();
-          } catch (err) {
-            log.error(`Test Failure: ${err}`);
-            done(err);
-          }
-        } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
-          done(error);
-        }
-      }).timeout(attemptTimeout);
-      it('should return status of each item if an array is passed', (done) => {
-        try {
-          const entityExist = a.entityInList(['Godric Gryffindor', 'XXXX'], cache);
-          try {
-            assert.equal(true, entityExist[0]);
-            assert.equal(false, entityExist[1]);
-            done();
-          } catch (err) {
-            log.error(`Test Failure: ${err}`);
-            done(err);
-          }
-        } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
-          done(error);
-        }
-      }).timeout(attemptTimeout);
-    });
-
-    describe('#capabilityResults', () => {
-      it('should have a capabilityResults function', (done) => {
-        try {
-          assert.equal(true, typeof a.capabilityResults === 'function');
-          done();
-        } catch (error) {
-          log.error(`Test Failure: ${error}`);
-          done(error);
-        }
-      });
-      it('should throw an error if needupdate is passed into the function', (done) => {
+      it('should throw an error if missing configuration file', (done) => {
         try {
-          const results = ['needupdate'];
-          a.capabilityResults(results, (data, error) => {
+          a.iapUpdateAdapterConfiguration(null, { name: 'fakeChange' }, null, null, null, null, (data, error) => {
             try {
-              const displayE = 'Could not load entity: unknown, into cache';
-              runErrorAsserts(data, error, 'AD.320', 'Test-Base-adapterBase-capabilityResults', displayE);
+              const displayE = 'configFile is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-Base-adapterBase-iapUpdateAdapterConfiguration', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -703,13 +599,12 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should throw an error if error is passed into the function', (done) => {
+      it('if not package.json, entity is required', (done) => {
         try {
-          const results = ['error'];
-          a.capabilityResults(results, (data, error) => {
+          a.iapUpdateAdapterConfiguration('notPackage', { name: 'fakeChange' }, null, null, null, null, (data, error) => {
             try {
-              const displayE = 'Could not verify entity in cache';
-              runErrorAsserts(data, error, 'AD.321', 'Test-Base-adapterBase-capabilityResults', displayE);
+              const displayE = 'Unsupported Configuration Change or Missing Entity';
+              runErrorAsserts(data, error, 'AD.999', 'Test-Base-adapterBase-iapUpdateAdapterConfiguration', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -721,12 +616,12 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should return null if nothing passed in', (done) => {
+      it('if not package.json, type is required', (done) => {
         try {
-          const results = null;
-          a.capabilityResults(results, (data, error) => {
+          a.iapUpdateAdapterConfiguration('notPackage', { name: 'fakeChange' }, 'entity', null, null, null, (data, error) => {
             try {
-              assert.equal(null, data);
+              const displayE = 'type is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-Base-adapterBase-iapUpdateAdapterConfiguration', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -738,12 +633,12 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should return true if results is not an array and is "found"', (done) => {
+      it('if not package.json, entity must be valid', (done) => {
         try {
-          const results = 'found';
-          a.capabilityResults(results, (data, error) => {
+          a.iapUpdateAdapterConfiguration('notPackage', { name: 'fakeChange' }, 'fakeEntity', 'fakeType', null, null, (data, error) => {
             try {
-              assert.equal(true, data[0]);
+              const displayE = 'Incomplete Configuration Change: Invalid Entity - fakeEntity';
+              runErrorAsserts(data, error, 'AD.999', 'Test-Base-adapterBase-iapUpdateAdapterConfiguration', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -755,12 +650,25 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should return false if results is not an array and is not "found"', (done) => {
+    });
+
+    describe('#iapSuspendAdapter', () => {
+      it('should have a iapSuspendAdapter function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapSuspendAdapter === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('should successfully suspend the adapter', (done) => {
         try {
-          const results = 'notfound';
-          a.capabilityResults(results, (data, error) => {
+          a.iapSuspendAdapter('nopause', (data, error) => {
             try {
-              assert.equal(false, data[0]);
+              assert.notEqual(null, data);
+              assert.notEqual(null, data.suspended);
+              assert.equal(true, data.suspended);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -772,14 +680,25 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should process an incoming array and return an array of values', (done) => {
+    });
+
+    describe('#iapUnsuspendAdapter', () => {
+      it('should have a iapUnsuspendAdapter function', (done) => {
         try {
-          const results = ['found', 'notFound', 'found'];
-          a.capabilityResults(results, (data, error) => {
+          assert.equal(true, typeof a.iapUnsuspendAdapter === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('should successfully unsuspend the adapter', (done) => {
+        try {
+          a.iapUnsuspendAdapter((data, error) => {
             try {
-              assert.equal(true, data[0]);
-              assert.equal(false, data[1]);
-              assert.equal(true, data[2]);
+              assert.notEqual(null, data);
+              assert.notEqual(null, data.suspend);
+              assert.equal(false, data.suspend);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -793,29 +712,21 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#getAllCapabilities', () => {
-      it('should have a getAllCapabilities function', (done) => {
+    describe('#iapGetAdapterQueue', () => {
+      it('should have a iapGetAdapterQueue function', (done) => {
         try {
-          assert.equal(true, typeof a.getAllCapabilities === 'function');
+          assert.equal(true, typeof a.iapGetAdapterQueue === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should have have capabilities returned', (done) => {
+      it('should get information for all of the requests currently in the queue', (done) => {
         try {
-          const expectedCapabilities = a.getAllCapabilities();
+          const expectedFunctions = a.iapGetAdapterQueue();
           try {
-            assert.notEqual(0, expectedCapabilities.length);
-            assert.equal('.system', expectedCapabilities[0].entity);
-            assert.equal(2, expectedCapabilities[0].actions.length);
-            assert.equal('getToken', expectedCapabilities[0].actions[0]);
-            assert.equal('healthcheck', expectedCapabilities[0].actions[1]);
-            for (let e = 1; e < expectedCapabilities.length; e += 1) {
-              assert.notEqual('', expectedCapabilities[e].entity);
-              assert.notEqual(0, expectedCapabilities[e].actions);
-            }
+            assert.equal(0, expectedFunctions.length);
             done();
           } catch (err) {
             log.error(`Test Failure: ${err}`);
@@ -828,23 +739,23 @@ describe('[unit] Adapter Base Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    // const returnedFunctions = ['updateAdapterConfiguration'];
-
-    describe('#updateAdapterConfiguration', () => {
-      it('should have a updateAdapterConfiguration function', (done) => {
+    describe('#iapFindAdapterPath', () => {
+      it('should have a iapFindAdapterPath function', (done) => {
         try {
-          assert.equal(true, typeof a.updateAdapterConfiguration === 'function');
+          assert.equal(true, typeof a.iapFindAdapterPath === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       });
-      it('should return no updated if no changes are provided', (done) => {
+      it('should fail - missing path', (done) => {
         try {
-          a.updateAdapterConfiguration(null, null, null, null, null, (data, error) => {
+          a.iapFindAdapterPath(null, (data, error) => {
             try {
-              assert.equal('No configuration updates to make', data.response);
+              assert.notEqual(null, error);
+              assert.notEqual(null, error.message);
+              assert.equal('NO PATH PROVIDED!', error.message);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -856,74 +767,258 @@ describe('[unit] Adapter Base Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should throw an error if missing configuration file', (done) => {
+    });
+
+    describe('#iapTroubleshootAdapter', () => {
+      it('should have a iapTroubleshootAdapter function', (done) => {
         try {
-          a.updateAdapterConfiguration(null, { name: 'fakeChange' }, null, null, null, (data, error) => {
-            try {
-              const displayE = 'configFile is required';
-              runErrorAsserts(data, error, 'AD.300', 'Test-Base-adapterBase-updateAdapterConfiguration', displayE);
-              done();
-            } catch (err) {
-              log.error(`Test Failure: ${err}`);
-              done(err);
-            }
-          });
+          assert.equal(true, typeof a.iapTroubleshootAdapter === 'function');
+          done();
         } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
+          log.error(`Test Failure: ${error}`);
           done(error);
         }
-      }).timeout(attemptTimeout);
-      it('if not package.json, entity is required', (done) => {
+      });
+    });
+
+    describe('#iapRunAdapterHealthcheck', () => {
+      it('should have a iapRunAdapterHealthcheck function', (done) => {
         try {
-          a.updateAdapterConfiguration('notPackage', { name: 'fakeChange' }, null, null, null, (data, error) => {
-            try {
-              const displayE = 'Unsupported Configuration Change or Missing Entity';
-              runErrorAsserts(data, error, 'AD.999', 'Test-Base-adapterBase-updateAdapterConfiguration', displayE);
-              done();
-            } catch (err) {
-              log.error(`Test Failure: ${err}`);
-              done(err);
-            }
-          });
+          assert.equal(true, typeof a.iapRunAdapterHealthcheck === 'function');
+          done();
         } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
+          log.error(`Test Failure: ${error}`);
           done(error);
         }
-      }).timeout(attemptTimeout);
-      it('if not package.json, type is required', (done) => {
+      });
+    });
+
+    describe('#iapRunAdapterConnectivity', () => {
+      it('should have a iapRunAdapterConnectivity function', (done) => {
         try {
-          a.updateAdapterConfiguration('notPackage', { name: 'fakeChange' }, 'entity', null, null, (data, error) => {
-            try {
-              const displayE = 'type is required';
-              runErrorAsserts(data, error, 'AD.300', 'Test-Base-adapterBase-updateAdapterConfiguration', displayE);
-              done();
-            } catch (err) {
-              log.error(`Test Failure: ${err}`);
-              done(err);
-            }
-          });
+          assert.equal(true, typeof a.iapRunAdapterConnectivity === 'function');
+          done();
         } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
+          log.error(`Test Failure: ${error}`);
           done(error);
         }
-      }).timeout(attemptTimeout);
-      it('if not package.json, entity must be valid', (done) => {
+      });
+    });
+
+    describe('#iapRunAdapterBasicGet', () => {
+      it('should have a iapRunAdapterBasicGet function', (done) => {
         try {
-          a.updateAdapterConfiguration('notPackage', { name: 'fakeChange' }, 'fakeEntity', 'fakeType', null, (data, error) => {
-            try {
-              const displayE = 'Incomplete Configuration Change: Invalid Entity - fakeEntity';
-              runErrorAsserts(data, error, 'AD.999', 'Test-Base-adapterBase-updateAdapterConfiguration', displayE);
-              done();
-            } catch (err) {
-              log.error(`Test Failure: ${err}`);
-              done(err);
-            }
-          });
+          assert.equal(true, typeof a.iapRunAdapterBasicGet === 'function');
+          done();
         } catch (error) {
-          log.error(`Adapter Exception: ${error}`);
+          log.error(`Test Failure: ${error}`);
           done(error);
         }
-      }).timeout(attemptTimeout);
+      });
+    });
+
+    describe('#iapMoveAdapterEntitiesToDB', () => {
+      it('should have a iapMoveAdapterEntitiesToDB function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapMoveAdapterEntitiesToDB === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapDeactivateTasks', () => {
+      it('should have a iapDeactivateTasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapDeactivateTasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapActivateTasks', () => {
+      it('should have a iapActivateTasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapActivateTasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapPopulateEntityCache', () => {
+      it('should have a iapPopulateEntityCache function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapPopulateEntityCache === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapRetrieveEntitiesCache', () => {
+      it('should have a iapRetrieveEntitiesCache function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapRetrieveEntitiesCache === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#hasEntities', () => {
+      it('should have a hasEntities function', (done) => {
+        try {
+          assert.equal(true, typeof a.hasEntities === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getDevice', () => {
+      it('should have a getDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getDevicesFiltered', () => {
+      it('should have a getDevicesFiltered function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevicesFiltered === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#isAlive', () => {
+      it('should have a isAlive function', (done) => {
+        try {
+          assert.equal(true, typeof a.isAlive === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getConfig', () => {
+      it('should have a getConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.getConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapGetDeviceCount', () => {
+      it('should have a iapGetDeviceCount function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapGetDeviceCount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapExpandedGenericAdapterRequest', () => {
+      it('should have a iapExpandedGenericAdapterRequest function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapExpandedGenericAdapterRequest === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#genericAdapterRequest', () => {
+      it('should have a genericAdapterRequest function', (done) => {
+        try {
+          assert.equal(true, typeof a.genericAdapterRequest === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#genericAdapterRequestNoBasePath', () => {
+      it('should have a genericAdapterRequestNoBasePath function', (done) => {
+        try {
+          assert.equal(true, typeof a.genericAdapterRequestNoBasePath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapRunAdapterLint', () => {
+      it('should have a iapRunAdapterLint function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapRunAdapterLint === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapRunAdapterTests', () => {
+      it('should have a iapRunAdapterTests function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapRunAdapterTests === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapGetAdapterInventory', () => {
+      it('should have a iapGetAdapterInventory function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapGetAdapterInventory === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
     });
   });
 });