@itentialopensource/adapter-nokia_altiplano 0.1.3 → 0.4.0

package/report/updateReport1647623246588.json

@@ -0,0 +1,95 @@
+{
+  "errors": [],
+  "statistics": [
+    {
+      "owner": "errorJson",
+      "description": "New adapter errors available for use",
+      "value": 0
+    },
+    {
+      "owner": "errorJson",
+      "description": "Adapter errors no longer available for use",
+      "value": 0
+    },
+    {
+      "owner": "errorJson",
+      "description": "Adapter errors that have been updated (e.g. recommendation changes)",
+      "value": 30
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of production dependencies",
+      "value": 13
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of development dependencies",
+      "value": 7
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of npm scripts",
+      "value": 23
+    },
+    {
+      "owner": "packageJson",
+      "description": "Runtime Library dependency",
+      "value": "^4.44.11"
+    },
+    {
+      "owner": "propertiesSchemaJson",
+      "description": "Adapter properties defined in the propertiesSchema file",
+      "value": 64
+    },
+    {
+      "owner": "readmeMd",
+      "description": "Number of lines in the README.md",
+      "value": 688
+    },
+    {
+      "owner": "unitTestJS",
+      "description": "Number of lines of code in unit tests",
+      "value": 1822
+    },
+    {
+      "owner": "unitTestJS",
+      "description": "Number of unit tests",
+      "value": 86
+    },
+    {
+      "owner": "integrationTestJS",
+      "description": "Number of lines of code in integration tests",
+      "value": 859
+    },
+    {
+      "owner": "integrationTestJS",
+      "description": "Number of integration tests",
+      "value": 20
+    },
+    {
+      "owner": "staticFile",
+      "description": "Number of lines of code in adapterBase.js",
+      "value": 1029
+    },
+    {
+      "owner": "staticFile",
+      "description": "Number of static files added",
+      "value": 34
+    },
+    {
+      "owner": "Overall",
+      "description": "Total lines of Code",
+      "value": 3710
+    },
+    {
+      "owner": "Overall",
+      "description": "Total Tests",
+      "value": 106
+    },
+    {
+      "owner": "Overall",
+      "description": "Total Files",
+      "value": 6
+    }
+  ]
+}

package/sampleProperties.json

@@ -7,7 +7,7 @@
     "base_path": "/rest",
     "version": "",
     "cache_location": "none",
-    "encode_pathvars": true,
+    "encode_pathvars": false,
     "save_metric": true,
     "stub": true,
     "protocol": "https",
@@ -20,7 +20,7 @@
       "token_cache": "local",
       "invalid_token_error": 401,
       "auth_field": "header.headers.Authorization",
-      "auth_field_format": "{token}",
+      "auth_field_format": "Bearer {token}",
       "auth_logging": false,
       "client_id": "",
       "client_secret": "",

package/test/integration/adapterTestIntegration.js

@@ -13,7 +13,10 @@ const winston = require('winston');
 const { expect } = require('chai');
 const { use } = require('chai');
 const td = require('testdouble');
+const util = require('util');
+const pronghorn = require('../../pronghorn.json');
 
+pronghorn.methodsByName = pronghorn.methods.reduce((result, meth) => ({ ...result, [meth.name]: meth }), {});
 const anything = td.matchers.anything();
 
 // stub and attemptTimeout are used throughout the code so set them here
@@ -468,6 +471,7 @@ describe('[integration] Nokia_altiplano Adapter Test', () => {
         }
       }
     };
+
     describe('#createOnt - errors', () => {
       it('should work if integrated but since no mockdata should error when run standalone', (done) => {
         try {
@@ -493,6 +497,31 @@ describe('[integration] Nokia_altiplano Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#createOntWithQuery - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createOntWithQuery(intentCreateOntBodyParam, {}, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-nokia_altiplano-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Intent', 'createOnt', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     const intentIntent = 'fakedata';
     describe('#dependentsSummaryFiber - errors', () => {
       it('should work if integrated but since no mockdata should error when run standalone', (done) => {
@@ -619,6 +648,56 @@ describe('[integration] Nokia_altiplano Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#auditIbnIntent - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.auditIbnIntent(intentIntent, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-nokia_altiplano-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Intent', 'auditIbnIntent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#synchronizeIbnIntent - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.synchronizeIbnIntent(intentIntent, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-nokia_altiplano-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Intent', 'synchronizeIbnIntent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#dependentsSummaryForDevice - errors', () => {
       it('should work if integrated but since no mockdata should error when run standalone', (done) => {
         try {
@@ -802,6 +881,56 @@ describe('[integration] Nokia_altiplano Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#modifyIbnIntent - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.modifyIbnIntent(intentIntent, intentLockOntBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-nokia_altiplano-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Intent', 'modifyIbnIntent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIbnIntent - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getIbnIntent(intentIntent, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-nokia_altiplano-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Intent', 'getIbnIntent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#deletel2User - errors', () => {
       it('should work if integrated but since no mockdata should error when run standalone', (done) => {
         try {
@@ -851,5 +980,30 @@ describe('[integration] Nokia_altiplano Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#deleteIbnIntent - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteIbnIntent(intentIntent, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-nokia_altiplano-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Intent', 'deleteIbnIntent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });

package/test/unit/adapterTestUnit.js

@@ -1132,6 +1132,18 @@ describe('[unit] Nokia_altiplano Adapter Test', () => {
       });
     });
 
+    describe('#moveEntitiesToDB', () => {
+      it('should have a moveEntitiesToDB function', (done) => {
+        try {
+          assert.equal(true, typeof a.moveEntitiesToDB === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     describe('#checkActionFiles', () => {
       it('should have a checkActionFiles function', (done) => {
         try {
@@ -1261,6 +1273,90 @@ describe('[unit] Nokia_altiplano Adapter Test', () => {
     //   }).timeout(attemptTimeout);
     // });
 
+    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('#hasDevices', () => {
+      it('should have a hasDevices function', (done) => {
+        try {
+          assert.equal(true, typeof a.hasDevices === '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('#getCount', () => {
+      it('should have a getCount function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     /*
     -----------------------------------------------------------------------
     -----------------------------------------------------------------------
@@ -1398,6 +1494,35 @@ describe('[unit] Nokia_altiplano Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#createOntWithQuery - errors', () => {
+      it('should have a createOntWithQuery function', (done) => {
+        try {
+          assert.equal(true, typeof a.createOntWithQuery === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createOntWithQuery(null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-createOntWithQuery', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#getOnt - errors', () => {
       it('should have a getOnt function', (done) => {
         try {
@@ -1721,5 +1846,167 @@ describe('[unit] Nokia_altiplano Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getIbnIntent - errors', () => {
+      it('should have a getIbnIntent function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIbnIntent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing intent', (done) => {
+        try {
+          a.getIbnIntent(null, (data, error) => {
+            try {
+              const displayE = 'intent is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-getIbnIntent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#modifyIbnIntent - errors', () => {
+      it('should have a modifyIbnIntent function', (done) => {
+        try {
+          assert.equal(true, typeof a.modifyIbnIntent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing intent', (done) => {
+        try {
+          a.modifyIbnIntent(null, null, (data, error) => {
+            try {
+              const displayE = 'intent is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-modifyIbnIntent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.modifyIbnIntent('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-modifyIbnIntent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteIbnIntent - errors', () => {
+      it('should have a deleteIbnIntent function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteIbnIntent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing intent', (done) => {
+        try {
+          a.deleteIbnIntent(null, (data, error) => {
+            try {
+              const displayE = 'intent is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-deleteIbnIntent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#synchronizeIbnIntent - errors', () => {
+      it('should have a synchronizeIbnIntent function', (done) => {
+        try {
+          assert.equal(true, typeof a.synchronizeIbnIntent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing intent', (done) => {
+        try {
+          a.synchronizeIbnIntent(null, (data, error) => {
+            try {
+              const displayE = 'intent is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-synchronizeIbnIntent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#auditIbnIntent - errors', () => {
+      it('should have a auditIbnIntent function', (done) => {
+        try {
+          assert.equal(true, typeof a.auditIbnIntent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing intent', (done) => {
+        try {
+          a.auditIbnIntent(null, (data, error) => {
+            try {
+              const displayE = 'intent is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nokia_altiplano-adapter-auditIbnIntent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });

package/utils/basicGet.js

@@ -6,11 +6,8 @@
 /* eslint import/no-unresolved: warn */
 /* eslint import/no-dynamic-require: warn */
 
-const path = require('path');
 const winston = require('winston');
 
-const utils = require(path.join(__dirname, 'tbUtils'));
-
 const logLevel = 'none';
 const myCustomLevels = {
   levels: {
@@ -47,20 +44,6 @@ const basicGet = {
       adapter.id,
       adapterProps
     );
-  },
-
-  /**
-   * @summary connect to mongodb
-   *
-   * @function connect
-   * @param {Object} properties - pronghornProps
-   */
-  connect: async function connect(properties) {
-    // Connect to Mongo
-    const { MongoDBConnection } = require(path.join(utils.getDirname(), '../../../', '@itential/database'));
-    const connection = new MongoDBConnection(properties.mongoProps);
-    const database = await connection.connect(true);
-    return database;
   }
 };
 

package/utils/modify.js

@@ -3,7 +3,7 @@ const Ajv = require('ajv');
 const rls = require('readline-sync');
 const { execSync } = require('child_process');
 const { existsSync } = require('fs-extra');
-const { getAdapterConfig } = require('./troubleshootingAdapter');
+const { getAdapterConfig } = require('./tbUtils');
 const { name } = require('../package.json');
 const propertiesSchema = require('../propertiesSchema.json');