@itentialopensource/adapter-netbox_v33 0.1.1 → 2.0.0

package/test/integration/adapterTestIntegration.js

@@ -23527,5 +23527,1280 @@ describe('[integration] Netbox_v33 Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getDcimVirtualDeviceContexts - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDcimVirtualDeviceContexts(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(2, data.response.count);
+                assert.equal('string', data.response.next);
+                assert.equal('string', data.response.previous);
+                assert.equal(true, Array.isArray(data.response.results));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'getDcimVirtualDeviceContexts', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dcimPostDcimVirtualDeviceContextsBodyParam = {
+      name: 'string',
+      status: 'offline'
+    };
+    describe('#postDcimVirtualDeviceContexts - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postDcimVirtualDeviceContexts(dcimPostDcimVirtualDeviceContextsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'postDcimVirtualDeviceContexts', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dcimPutDcimVirtualDeviceContextsBodyParam = {
+      name: 'string',
+      status: 'offline'
+    };
+    describe('#putDcimVirtualDeviceContexts - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putDcimVirtualDeviceContexts(dcimPutDcimVirtualDeviceContextsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'putDcimVirtualDeviceContexts', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dcimPatchDcimVirtualDeviceContextsBodyParam = {
+      name: 'string',
+      status: 'planned'
+    };
+    describe('#patchDcimVirtualDeviceContexts - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchDcimVirtualDeviceContexts(dcimPatchDcimVirtualDeviceContextsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'patchDcimVirtualDeviceContexts', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDcimVirtualDeviceContexts - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteDcimVirtualDeviceContexts((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'deleteDcimVirtualDeviceContexts', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDcimVirtualDeviceContextsId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDcimVirtualDeviceContextsId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'getDcimVirtualDeviceContextsId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dcimPutDcimVirtualDeviceContextsIdBodyParam = {
+      name: 'string',
+      status: 'planned'
+    };
+    describe('#putDcimVirtualDeviceContextsId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putDcimVirtualDeviceContextsId(555, dcimPutDcimVirtualDeviceContextsIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'putDcimVirtualDeviceContextsId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dcimPatchDcimVirtualDeviceContextsIdBodyParam = {
+      name: 'string',
+      status: 'offline'
+    };
+    describe('#patchDcimVirtualDeviceContextsId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchDcimVirtualDeviceContextsId(555, dcimPatchDcimVirtualDeviceContextsIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'patchDcimVirtualDeviceContextsId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDcimVirtualDeviceContextsId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteDcimVirtualDeviceContextsId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dcim', 'deleteDcimVirtualDeviceContextsId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExtrasSavedFilters - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getExtrasSavedFilters(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(8, data.response.count);
+                assert.equal('string', data.response.next);
+                assert.equal('string', data.response.previous);
+                assert.equal(true, Array.isArray(data.response.results));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'getExtrasSavedFilters', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const extrasPostExtrasSavedFiltersBodyParam = {
+      content_types: [
+        'string'
+      ],
+      name: 'string',
+      slug: 'string',
+      parameters: {}
+    };
+    describe('#postExtrasSavedFilters - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postExtrasSavedFilters(extrasPostExtrasSavedFiltersBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'postExtrasSavedFilters', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const extrasPutExtrasSavedFiltersBodyParam = {
+      content_types: [
+        'string'
+      ],
+      name: 'string',
+      slug: 'string',
+      parameters: {}
+    };
+    describe('#putExtrasSavedFilters - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putExtrasSavedFilters(extrasPutExtrasSavedFiltersBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'putExtrasSavedFilters', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const extrasPatchExtrasSavedFiltersBodyParam = {
+      content_types: [
+        'string'
+      ],
+      name: 'string',
+      slug: 'string',
+      parameters: {}
+    };
+    describe('#patchExtrasSavedFilters - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchExtrasSavedFilters(extrasPatchExtrasSavedFiltersBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'patchExtrasSavedFilters', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteExtrasSavedFilters - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteExtrasSavedFilters((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'deleteExtrasSavedFilters', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExtrasSavedFiltersId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getExtrasSavedFiltersId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'getExtrasSavedFiltersId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const extrasPutExtrasSavedFiltersIdBodyParam = {
+      content_types: [
+        'string'
+      ],
+      name: 'string',
+      slug: 'string',
+      parameters: {}
+    };
+    describe('#putExtrasSavedFiltersId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putExtrasSavedFiltersId(555, extrasPutExtrasSavedFiltersIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'putExtrasSavedFiltersId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const extrasPatchExtrasSavedFiltersIdBodyParam = {
+      content_types: [
+        'string'
+      ],
+      name: 'string',
+      slug: 'string',
+      parameters: {}
+    };
+    describe('#patchExtrasSavedFiltersId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchExtrasSavedFiltersId(555, extrasPatchExtrasSavedFiltersIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'patchExtrasSavedFiltersId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteExtrasSavedFiltersId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteExtrasSavedFiltersId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Extras', 'deleteExtrasSavedFiltersId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPluginsServicePoolsCandidateConfig - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getPluginsServicePoolsCandidateConfig(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(3, data.response.count);
+                assert.equal('string', data.response.next);
+                assert.equal('string', data.response.previous);
+                assert.equal(true, Array.isArray(data.response.results));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'getPluginsServicePoolsCandidateConfig', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPostPluginsServicePoolsCandidateConfigBodyParam = {
+      service_order: 5
+    };
+    describe('#postPluginsServicePoolsCandidateConfig - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postPluginsServicePoolsCandidateConfig(pluginsPostPluginsServicePoolsCandidateConfigBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'postPluginsServicePoolsCandidateConfig', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPutPluginsServicePoolsCandidateConfigBodyParam = {
+      service_order: 6
+    };
+    describe('#putPluginsServicePoolsCandidateConfig - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putPluginsServicePoolsCandidateConfig(pluginsPutPluginsServicePoolsCandidateConfigBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'putPluginsServicePoolsCandidateConfig', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPatchPluginsServicePoolsCandidateConfigBodyParam = {
+      service_order: 9
+    };
+    describe('#patchPluginsServicePoolsCandidateConfig - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchPluginsServicePoolsCandidateConfig(pluginsPatchPluginsServicePoolsCandidateConfigBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'patchPluginsServicePoolsCandidateConfig', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePluginsServicePoolsCandidateConfig - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePluginsServicePoolsCandidateConfig((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'deletePluginsServicePoolsCandidateConfig', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPluginsServicePoolsCandidateConfigId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getPluginsServicePoolsCandidateConfigId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'getPluginsServicePoolsCandidateConfigId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPutPluginsServicePoolsCandidateConfigIdBodyParam = {
+      service_order: 7
+    };
+    describe('#putPluginsServicePoolsCandidateConfigId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putPluginsServicePoolsCandidateConfigId(555, pluginsPutPluginsServicePoolsCandidateConfigIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'putPluginsServicePoolsCandidateConfigId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPatchPluginsServicePoolsCandidateConfigIdBodyParam = {
+      service_order: 6
+    };
+    describe('#patchPluginsServicePoolsCandidateConfigId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchPluginsServicePoolsCandidateConfigId(555, pluginsPatchPluginsServicePoolsCandidateConfigIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'patchPluginsServicePoolsCandidateConfigId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePluginsServicePoolsCandidateConfigId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePluginsServicePoolsCandidateConfigId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'deletePluginsServicePoolsCandidateConfigId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPluginsServicePoolsCustomService - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getPluginsServicePoolsCustomService(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(9, data.response.count);
+                assert.equal('string', data.response.next);
+                assert.equal('string', data.response.previous);
+                assert.equal(true, Array.isArray(data.response.results));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'getPluginsServicePoolsCustomService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPostPluginsServicePoolsCustomServiceBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      service_type: 'L3VPN',
+      tmf638_payload: {}
+    };
+    describe('#postPluginsServicePoolsCustomService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postPluginsServicePoolsCustomService(pluginsPostPluginsServicePoolsCustomServiceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'postPluginsServicePoolsCustomService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPutPluginsServicePoolsCustomServiceBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      service_type: 'PORT A',
+      tmf638_payload: {}
+    };
+    describe('#putPluginsServicePoolsCustomService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putPluginsServicePoolsCustomService(pluginsPutPluginsServicePoolsCustomServiceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'putPluginsServicePoolsCustomService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPatchPluginsServicePoolsCustomServiceBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      service_type: 'L3VPN',
+      tmf638_payload: {}
+    };
+    describe('#patchPluginsServicePoolsCustomService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchPluginsServicePoolsCustomService(pluginsPatchPluginsServicePoolsCustomServiceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'patchPluginsServicePoolsCustomService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePluginsServicePoolsCustomService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePluginsServicePoolsCustomService((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'deletePluginsServicePoolsCustomService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPluginsServicePoolsCustomServiceId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getPluginsServicePoolsCustomServiceId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'getPluginsServicePoolsCustomServiceId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPutPluginsServicePoolsCustomServiceIdBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      service_type: 'L3VPN',
+      tmf638_payload: {}
+    };
+    describe('#putPluginsServicePoolsCustomServiceId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putPluginsServicePoolsCustomServiceId(555, pluginsPutPluginsServicePoolsCustomServiceIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'putPluginsServicePoolsCustomServiceId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPatchPluginsServicePoolsCustomServiceIdBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      service_type: 'L3VPN',
+      tmf638_payload: {}
+    };
+    describe('#patchPluginsServicePoolsCustomServiceId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchPluginsServicePoolsCustomServiceId(555, pluginsPatchPluginsServicePoolsCustomServiceIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'patchPluginsServicePoolsCustomServiceId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePluginsServicePoolsCustomServiceId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePluginsServicePoolsCustomServiceId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'deletePluginsServicePoolsCustomServiceId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPluginsServicePoolsServiceOrder - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getPluginsServicePoolsServiceOrder(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(1, data.response.count);
+                assert.equal('string', data.response.next);
+                assert.equal('string', data.response.previous);
+                assert.equal(true, Array.isArray(data.response.results));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'getPluginsServicePoolsServiceOrder', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPostPluginsServicePoolsServiceOrderBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      state: 'cancelled',
+      tmf641_payload: {}
+    };
+    describe('#postPluginsServicePoolsServiceOrder - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postPluginsServicePoolsServiceOrder(pluginsPostPluginsServicePoolsServiceOrderBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'postPluginsServicePoolsServiceOrder', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPutPluginsServicePoolsServiceOrderBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      state: 'released',
+      tmf641_payload: {}
+    };
+    describe('#putPluginsServicePoolsServiceOrder - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putPluginsServicePoolsServiceOrder(pluginsPutPluginsServicePoolsServiceOrderBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'putPluginsServicePoolsServiceOrder', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPatchPluginsServicePoolsServiceOrderBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      state: 'released',
+      tmf641_payload: {}
+    };
+    describe('#patchPluginsServicePoolsServiceOrder - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchPluginsServicePoolsServiceOrder(pluginsPatchPluginsServicePoolsServiceOrderBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'patchPluginsServicePoolsServiceOrder', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePluginsServicePoolsServiceOrder - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePluginsServicePoolsServiceOrder((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'deletePluginsServicePoolsServiceOrder', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPluginsServicePoolsServiceOrderId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getPluginsServicePoolsServiceOrderId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'getPluginsServicePoolsServiceOrderId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPutPluginsServicePoolsServiceOrderIdBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      state: 'confirmed',
+      tmf641_payload: {}
+    };
+    describe('#putPluginsServicePoolsServiceOrderId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putPluginsServicePoolsServiceOrderId(555, pluginsPutPluginsServicePoolsServiceOrderIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'putPluginsServicePoolsServiceOrderId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const pluginsPatchPluginsServicePoolsServiceOrderIdBodyParam = {
+      uuid: 'string',
+      name: 'string',
+      state: 'open',
+      tmf641_payload: {}
+    };
+    describe('#patchPluginsServicePoolsServiceOrderId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchPluginsServicePoolsServiceOrderId(555, pluginsPatchPluginsServicePoolsServiceOrderIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'patchPluginsServicePoolsServiceOrderId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePluginsServicePoolsServiceOrderId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePluginsServicePoolsServiceOrderId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-netbox_v33-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Plugins', 'deletePluginsServicePoolsServiceOrderId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });