@itentialopensource/adapter-paragon_insights 0.1.1 → 0.1.3

package/propertiesSchema.json

@@ -122,7 +122,8 @@
             "static_token",
             "jwt_token",
             "request_token",
-            "no_authentication"
+            "no_authentication", 
+            "multi_step_authentication"
           ]
         },
         "username": {

package/report/adapterInfo.json

@@ -1,10 +1,10 @@
 {
-  "version": "0.1.0",
-  "configLines": 22633,
+  "version": "0.1.2",
+  "configLines": 23439,
   "scriptLines": 1795,
-  "codeLines": 48111,
-  "testLines": 28055,
-  "testCases": 1497,
-  "totalCodeLines": 77961,
-  "wfTasks": 476
+  "codeLines": 50091,
+  "testLines": 29130,
+  "testCases": 1556,
+  "totalCodeLines": 81016,
+  "wfTasks": 496
 }

package/sampleProperties.json

@@ -13,15 +13,49 @@
     "stub": false,
     "protocol": "https",
     "authentication": {
-      "auth_method": "request_token",
-      "username": "username",
-      "password": "password",
+      "auth_method": "multi_step_authentication",
+      "multiStepAuthCalls": [
+        {
+          "name": "getFirstToken",
+          "requestFields": {
+            "user": {
+              "domain": "",
+              "name": ""
+            },
+            "password": "",
+            "methods": [
+              "PASSWORD"
+            ]
+          },
+          "responseFields": {
+            "firstIdToken": "id_token",
+            "scopeId": "scopes.0.id"
+          },
+          "successfullResponseCode": 200
+        },
+        {
+          "name": "getSecondToken",
+          "requestFields": {
+            "token": "{getFirstToken.responseFields.firstIdToken}",
+            "scopeId": "{getFirstToken.responseFields.scopeId}",
+            "methods": [
+              "TOKEN"
+            ]
+          },
+          "responseFields": {
+            "tokenp2": "id_token"
+          },
+          "successfullResponseCode": 200
+        }
+      ],
+      "username": "admin",
+      "password": "pass",
       "token": "token",
       "token_timeout": 1800000,
       "token_cache": "local",
       "invalid_token_error": 401,
       "auth_field": "header.headers.x-iam-token",
-      "auth_field_format": "{token}",
+      "auth_field_format": "{tokenp2}",
       "auth_logging": false,
       "client_id": "",
       "client_secret": "",

package/test/integration/adapterTestIntegration.js

@@ -12265,5 +12265,515 @@ describe('[integration] Paragon_insights Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#retrieveDeviceTriggerInfo - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveDeviceTriggerInfo('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Configuration', 'retrieveDeviceTriggerInfo', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeIcebergDevicesFromGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIcebergDevicesFromGroup('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Configuration', 'removeIcebergDevicesFromGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeIcebergNetworkGroupNetworkGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIcebergNetworkGroupNetworkGroupById('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Configuration', 'removeIcebergNetworkGroupNetworkGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestSettingsPaa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestSettingsPaa(null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestSettingsPaa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteHealthbotIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteHealthbotIngestPaaByPaaName('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'deleteHealthbotIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestPaaByPaaName('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configUpdateIngestPaaByPaaNameBodyParam = {};
+    describe('#updateIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateIngestPaaByPaaName('fakedata', configUpdateIngestPaaByPaaNameBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'updateIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configCreateIngestPaaByPaaNameBodyParam = {};
+    describe('#createIngestPaaByPaaName - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createIngestPaaByPaaName('fakedata', configCreateIngestPaaByPaaNameBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'createIngestPaaByPaaName', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteHealthbotIngestIfa((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'deleteHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfa(null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configCreateHealthbotIngestIfaBodyParam = {};
+    describe('#createHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createHealthbotIngestIfa(configCreateHealthbotIngestIfaBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'createHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configUpdateHealthbotIngestIfaBodyParam = {};
+    describe('#updateHealthbotIngestIfa - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateHealthbotIngestIfa(configUpdateHealthbotIngestIfaBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'updateHealthbotIngestIfa', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfaDeviceIds - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfaDeviceIds(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response[0]);
+                assert.equal('string', data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfaDeviceIds', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfaDevices - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfaDevices(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfaDevices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteHealthbotIngestIfaDeviceById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'deleteHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.retrieveHealthbotIngestIfaDeviceById(555, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'retrieveHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configCreateHealthbotIngestIfaDeviceByIdBodyParam = {};
+    describe('#createHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createHealthbotIngestIfaDeviceById(555, configCreateHealthbotIngestIfaDeviceByIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'createHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const configUpdateHealthbotIngestIfaDeviceByIdBodyParam = {};
+    describe('#updateHealthbotIngestIfaDeviceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateHealthbotIngestIfaDeviceById('fakedata', configUpdateHealthbotIngestIfaDeviceByIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Config', 'updateHealthbotIngestIfaDeviceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const utilityPostJunosEncodeBodyParam = {};
+    describe('#postJunosEncode - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postJunosEncode(utilityPostJunosEncodeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Utility', 'postJunosEncode', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const utilityPostJunosDecodeBodyParam = {};
+    describe('#postJunosDecode - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postJunosDecode(utilityPostJunosDecodeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_insights-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Utility', 'postJunosDecode', '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/adapterBaseTestUnit.js

@@ -831,9 +831,11 @@ describe('[unit] Adapter Base Test', () => {
             assert.equal('patchGenericNoBase', expectedCapabilities[0].actions[8]);
             assert.equal('deleteGenericNoBase', expectedCapabilities[0].actions[9]);
             assert.equal('.system', expectedCapabilities[1].entity);
-            assert.equal(2, expectedCapabilities[1].actions.length);
+            assert.equal(4, expectedCapabilities[1].actions.length);
             assert.equal('getToken', expectedCapabilities[1].actions[0]);
-            assert.equal('healthcheck', expectedCapabilities[1].actions[1]);
+            assert.equal('MFA_Step_1', expectedCapabilities[1].actions[1]);
+            assert.equal('MFA_Step_2', expectedCapabilities[1].actions[2]);
+            assert.equal('healthcheck', expectedCapabilities[1].actions[3]);
             for (let e = 1; e < expectedCapabilities.length; e += 1) {
               assert.notEqual('', expectedCapabilities[e].entity);
               assert.notEqual(null, expectedCapabilities[e].actions);