@itentialopensource/adapter-gcp_compute 0.2.0 → 1.1.0

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
@@ -46,8 +49,8 @@ global.pronghornProps = {
       properties: {
         host,
         port,
-        base_path: '/compute/v1/projects',
-        version: '',
+        base_path: '/compute',
+        version: 'v1',
         cache_location: 'none',
         encode_pathvars: true,
         save_metric: false,
@@ -64,6 +67,9 @@ global.pronghornProps = {
           auth_field: 'header.headers.Authorization',
           auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
           auth_logging: false,
+          client_id: '',
+          client_secret: '',
+          grant_type: '',
           configureGtoken: {
             email: '',
             scope: 'https://www.googleapis.com/auth/cloud-platform',
@@ -76,7 +82,8 @@ global.pronghornProps = {
         },
         healthcheck: {
           type: 'none',
-          frequency: 60000
+          frequency: 60000,
+          query_object: {}
         },
         throttle: {
           throttle_enabled: false,
@@ -318,7 +325,7 @@ function saveMockData(entityName, actionName, descriptor, responseData) {
 }
 
 // require the adapter that we are going to be using
-const GcpCompute = require('../../adapter.js');
+const GcpCompute = require('../../adapter');
 
 // begin the testing - these should be pretty well defined between the describe and the it!
 describe('[integration] GcpCompute Adapter Test', () => {
@@ -349,6 +356,8 @@ describe('[integration] GcpCompute Adapter Test', () => {
         try {
           assert.notEqual(null, a);
           assert.notEqual(undefined, a);
+          const checkId = global.pronghornProps.adapterProps.adapters[0].id;
+          assert.equal(checkId, a.id);
           assert.notEqual(null, a.allProps);
           const check = global.pronghornProps.adapterProps.adapters[0].properties.healthcheck.type;
           assert.equal(check, a.healthcheckType);
@@ -30804,5 +30813,455 @@ describe('[integration] GcpCompute Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#addFirewallPolicyAssociation - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addFirewallPolicyAssociation('fakedata', { key: 'value' }, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'addFirewallPolicyAssociation', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addFirewallPolicyRule - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addFirewallPolicyRule('fakedata', { key: 'value' }, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'addFirewallPolicyRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#cloneFirewallPolicyRule - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.cloneFirewallPolicyRule('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'cloneFirewallPolicyRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteFirewallPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.deleteFirewallPolicy('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteFirewallPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFirewallPolicy('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getFirewallPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallPolicyAssociation - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFirewallPolicyAssociation('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.name);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getFirewallPolicyAssociation', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallPolicyIamPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFirewallPolicyIamPolicy('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('BwWWja0YfJA=', data.response.etag);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getFirewallPolicyIamPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallPolicyRule - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFirewallPolicyRule('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.description);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getFirewallPolicyRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#insertFirewallPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.insertFirewallPolicy({ key: 'fakedata' }, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'insertFirewallPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listFirewallPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.listFirewallPolicy(null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'listFirewallPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listFirewallPolicyAssociations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.listFirewallPolicyAssociations(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.kind);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'listFirewallPolicyAssociations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#moveFirewallPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.moveFirewallPolicy('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.kind);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'moveFirewallPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchFirewallPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.patchFirewallPolicy('fakedata', { key: 'fakedata' }, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.kind);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'patchFirewallPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchFirewallPolicyRule - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.patchFirewallPolicyRule('fakedata', { key: 'fakedata' }, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.kind);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'patchFirewallPolicyRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeFirewallPolicyAssociation - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.removeFirewallPolicyAssociation('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.kind);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'removeFirewallPolicyAssociation', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeFirewallPolicyRule - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.removeFirewallPolicyRule('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response.kind);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'removeFirewallPolicyRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#setFirewallPolicyIamPolicy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.setFirewallPolicyIamPolicy('fakedata', { key: 'fakedata' }, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('BwWWja0YfJA=', data.response.etag);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'setFirewallPolicyIamPolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#testFirewallPolicyIamPermissions - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.testFirewallPolicyIamPermissions('fakedata', { key: 'fakedata' }, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.notEqual(null, data.response.permissions);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'testFirewallPolicyIamPermissions', '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

@@ -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: '',
@@ -189,7 +197,7 @@ function runErrorAsserts(data, error, code, origin, displayStr) {
 }
 
 // require the adapter that we are going to be using
-const AdapterBase = require('../../adapterBase.js');
+const AdapterBase = require('../../adapterBase');
 
 // delete the .DS_Store directory in entities -- otherwise this will cause errors
 const dirPath = path.join(__dirname, '../../entities/.DS_Store');
@@ -309,7 +317,7 @@ describe('[unit] Adapter Base Test', () => {
       });
       it('should return a list of functions', (done) => {
         const returnedFunctions = ['addEntityCache', 'capabilityResults', 'checkActionFiles', 'checkProperties', 'connect', 'encryptProperty',
-          'entityInList', 'findPath', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck',
+          'entityInList', 'findPath', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck', 'moveEntitiesToDB',
           'refreshProperties', 'runBasicGet', 'runConnectivity', 'runHealthcheck', 'suspend', 'troubleshoot', 'unsuspend', 'updateAdapterConfiguration', 'addListener',
           'emit', 'eventNames', 'getMaxListeners', 'listenerCount', 'listeners', 'off', 'on', 'once', 'prependListener',
           'prependOnceListener', 'rawListeners', 'removeAllListeners', 'removeListener', 'setMaxListeners'];