npm - @itentialopensource/adapter-nautobot_v2 - Versions diffs - 0.3.2 → 0.4.0 - Mend

@itentialopensource/adapter-nautobot_v2 0.3.2 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/CALLS.md +697 -0
package/adapter.js +12798 -0
package/entities/Cloud/action.json +1260 -0
package/entities/Cloud/schema.json +1169 -0
package/entities/Core/action.json +24 -0
package/entities/Core/schema.json +19 -0
package/entities/Metrics/action.json +25 -0
package/entities/Metrics/schema.json +19 -0
package/entities/Ui/action.json +24 -0
package/entities/Ui/schema.json +19 -0
package/entities/Wireless/action.json +1037 -0
package/entities/Wireless/schema.json +2181 -0
package/package.json +2 -2
package/pronghorn.json +13605 -0
package/report/adapterInfo.json +7 -7
package/test/integration/adapterTestIntegration.js +3063 -0
package/test/unit/adapterTestUnit.js +3466 -0

package/test/unit/adapterTestUnit.js CHANGED Viewed

@@ -47329,5 +47329,3471 @@ describe('[unit] Nautobot_v2 Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+    describe('#getCloudCloudAccounts - errors', () => {
+      it('should have a getCloudCloudAccounts function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudAccounts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudAccounts - errors', () => {
+      it('should have a postCloudCloudAccounts function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudAccounts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudAccounts('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudAccounts', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudAccounts - errors', () => {
+      it('should have a putCloudCloudAccounts function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudAccounts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudAccounts('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudAccounts', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudAccounts - errors', () => {
+      it('should have a patchCloudCloudAccounts function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudAccounts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchCloudCloudAccounts('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudAccounts', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudAccounts - errors', () => {
+      it('should have a deleteCloudCloudAccounts function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudAccounts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteCloudCloudAccounts('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudAccounts', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudAccountsId - errors', () => {
+      it('should have a getCloudCloudAccountsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudAccountsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudAccountsId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudAccountsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudAccountsId - errors', () => {
+      it('should have a putCloudCloudAccountsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudAccountsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putCloudCloudAccountsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudAccountsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudAccountsId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudAccountsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudAccountsId - errors', () => {
+      it('should have a patchCloudCloudAccountsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudAccountsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchCloudCloudAccountsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudAccountsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudAccountsId - errors', () => {
+      it('should have a deleteCloudCloudAccountsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudAccountsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteCloudCloudAccountsId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudAccountsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudAccountsIdNotes - errors', () => {
+      it('should have a getCloudCloudAccountsIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudAccountsIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudAccountsIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudAccountsIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudAccountsIdNotes - errors', () => {
+      it('should have a postCloudCloudAccountsIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudAccountsIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postCloudCloudAccountsIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudAccountsIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudAccountsIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudAccountsIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudNetworkPrefixAssignments - errors', () => {
+      it('should have a getCloudCloudNetworkPrefixAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudNetworkPrefixAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudNetworkPrefixAssignments - errors', () => {
+      it('should have a postCloudCloudNetworkPrefixAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudNetworkPrefixAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudNetworkPrefixAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudNetworkPrefixAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudNetworkPrefixAssignments - errors', () => {
+      it('should have a putCloudCloudNetworkPrefixAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudNetworkPrefixAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudNetworkPrefixAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudNetworkPrefixAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudNetworkPrefixAssignments - errors', () => {
+      it('should have a patchCloudCloudNetworkPrefixAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudNetworkPrefixAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchCloudCloudNetworkPrefixAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudNetworkPrefixAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudNetworkPrefixAssignments - errors', () => {
+      it('should have a deleteCloudCloudNetworkPrefixAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudNetworkPrefixAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteCloudCloudNetworkPrefixAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudNetworkPrefixAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudNetworkPrefixAssignmentsId - errors', () => {
+      it('should have a getCloudCloudNetworkPrefixAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudNetworkPrefixAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudNetworkPrefixAssignmentsId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudNetworkPrefixAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudNetworkPrefixAssignmentsId - errors', () => {
+      it('should have a putCloudCloudNetworkPrefixAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudNetworkPrefixAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putCloudCloudNetworkPrefixAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudNetworkPrefixAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudNetworkPrefixAssignmentsId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudNetworkPrefixAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudNetworkPrefixAssignmentsId - errors', () => {
+      it('should have a patchCloudCloudNetworkPrefixAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudNetworkPrefixAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchCloudCloudNetworkPrefixAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudNetworkPrefixAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudNetworkPrefixAssignmentsId - errors', () => {
+      it('should have a deleteCloudCloudNetworkPrefixAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudNetworkPrefixAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteCloudCloudNetworkPrefixAssignmentsId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudNetworkPrefixAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudNetworks - errors', () => {
+      it('should have a getCloudCloudNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudNetworks - errors', () => {
+      it('should have a postCloudCloudNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudNetworks - errors', () => {
+      it('should have a putCloudCloudNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudNetworks - errors', () => {
+      it('should have a patchCloudCloudNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchCloudCloudNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudNetworks - errors', () => {
+      it('should have a deleteCloudCloudNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteCloudCloudNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudNetworksId - errors', () => {
+      it('should have a getCloudCloudNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudNetworksId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudNetworksId - errors', () => {
+      it('should have a putCloudCloudNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putCloudCloudNetworksId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudNetworksId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudNetworksId - errors', () => {
+      it('should have a patchCloudCloudNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchCloudCloudNetworksId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudNetworksId - errors', () => {
+      it('should have a deleteCloudCloudNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteCloudCloudNetworksId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudNetworksIdNotes - errors', () => {
+      it('should have a getCloudCloudNetworksIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudNetworksIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudNetworksIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudNetworksIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudNetworksIdNotes - errors', () => {
+      it('should have a postCloudCloudNetworksIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudNetworksIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postCloudCloudNetworksIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudNetworksIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudNetworksIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudNetworksIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudResourceTypes - errors', () => {
+      it('should have a getCloudCloudResourceTypes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudResourceTypes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudResourceTypes - errors', () => {
+      it('should have a postCloudCloudResourceTypes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudResourceTypes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudResourceTypes('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudResourceTypes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudResourceTypes - errors', () => {
+      it('should have a putCloudCloudResourceTypes function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudResourceTypes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudResourceTypes('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudResourceTypes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudResourceTypes - errors', () => {
+      it('should have a patchCloudCloudResourceTypes function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudResourceTypes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchCloudCloudResourceTypes('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudResourceTypes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudResourceTypes - errors', () => {
+      it('should have a deleteCloudCloudResourceTypes function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudResourceTypes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteCloudCloudResourceTypes('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudResourceTypes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudResourceTypesId - errors', () => {
+      it('should have a getCloudCloudResourceTypesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudResourceTypesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudResourceTypesId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudResourceTypesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudResourceTypesId - errors', () => {
+      it('should have a putCloudCloudResourceTypesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudResourceTypesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putCloudCloudResourceTypesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudResourceTypesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudResourceTypesId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudResourceTypesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudResourceTypesId - errors', () => {
+      it('should have a patchCloudCloudResourceTypesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudResourceTypesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchCloudCloudResourceTypesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudResourceTypesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudResourceTypesId - errors', () => {
+      it('should have a deleteCloudCloudResourceTypesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudResourceTypesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteCloudCloudResourceTypesId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudResourceTypesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudResourceTypesIdNotes - errors', () => {
+      it('should have a getCloudCloudResourceTypesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudResourceTypesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudResourceTypesIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudResourceTypesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudResourceTypesIdNotes - errors', () => {
+      it('should have a postCloudCloudResourceTypesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudResourceTypesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postCloudCloudResourceTypesIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudResourceTypesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudResourceTypesIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudResourceTypesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudServiceNetworkAssignments - errors', () => {
+      it('should have a getCloudCloudServiceNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudServiceNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudServiceNetworkAssignments - errors', () => {
+      it('should have a postCloudCloudServiceNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudServiceNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudServiceNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudServiceNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudServiceNetworkAssignments - errors', () => {
+      it('should have a putCloudCloudServiceNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudServiceNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudServiceNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudServiceNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudServiceNetworkAssignments - errors', () => {
+      it('should have a patchCloudCloudServiceNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudServiceNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchCloudCloudServiceNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudServiceNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudServiceNetworkAssignments - errors', () => {
+      it('should have a deleteCloudCloudServiceNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudServiceNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteCloudCloudServiceNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudServiceNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudServiceNetworkAssignmentsId - errors', () => {
+      it('should have a getCloudCloudServiceNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudServiceNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudServiceNetworkAssignmentsId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudServiceNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudServiceNetworkAssignmentsId - errors', () => {
+      it('should have a putCloudCloudServiceNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudServiceNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putCloudCloudServiceNetworkAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudServiceNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudServiceNetworkAssignmentsId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudServiceNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudServiceNetworkAssignmentsId - errors', () => {
+      it('should have a patchCloudCloudServiceNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudServiceNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchCloudCloudServiceNetworkAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudServiceNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudServiceNetworkAssignmentsId - errors', () => {
+      it('should have a deleteCloudCloudServiceNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudServiceNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteCloudCloudServiceNetworkAssignmentsId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudServiceNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudServices - errors', () => {
+      it('should have a getCloudCloudServices function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudServices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudServices - errors', () => {
+      it('should have a postCloudCloudServices function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudServices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudServices('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudServices', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudServices - errors', () => {
+      it('should have a putCloudCloudServices function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudServices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudServices('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudServices', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudServices - errors', () => {
+      it('should have a patchCloudCloudServices function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudServices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchCloudCloudServices('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudServices', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudServices - errors', () => {
+      it('should have a deleteCloudCloudServices function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudServices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteCloudCloudServices('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudServices', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudServicesId - errors', () => {
+      it('should have a getCloudCloudServicesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudServicesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudServicesId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudServicesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putCloudCloudServicesId - errors', () => {
+      it('should have a putCloudCloudServicesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putCloudCloudServicesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putCloudCloudServicesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudServicesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putCloudCloudServicesId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putCloudCloudServicesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchCloudCloudServicesId - errors', () => {
+      it('should have a patchCloudCloudServicesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCloudCloudServicesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchCloudCloudServicesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchCloudCloudServicesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteCloudCloudServicesId - errors', () => {
+      it('should have a deleteCloudCloudServicesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCloudCloudServicesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteCloudCloudServicesId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteCloudCloudServicesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getCloudCloudServicesIdNotes - errors', () => {
+      it('should have a getCloudCloudServicesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudCloudServicesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getCloudCloudServicesIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getCloudCloudServicesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCloudCloudServicesIdNotes - errors', () => {
+      it('should have a postCloudCloudServicesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCloudCloudServicesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postCloudCloudServicesIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudServicesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCloudCloudServicesIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCloudCloudServicesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postCoreRenderJinjaTemplate - errors', () => {
+      it('should have a postCoreRenderJinjaTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCoreRenderJinjaTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCoreRenderJinjaTemplate('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postCoreRenderJinjaTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postUiCoreRenderJinjaTemplate - errors', () => {
+      it('should have a postUiCoreRenderJinjaTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.postUiCoreRenderJinjaTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postUiCoreRenderJinjaTemplate('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postUiCoreRenderJinjaTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessControllerManagedDeviceGroupRadioProfileAssignments - errors', () => {
+      it('should have a getWirelessControllerManagedDeviceGroupRadioProfileAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessControllerManagedDeviceGroupRadioProfileAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessControllerManagedDeviceGroupRadioProfileAssignments - errors', () => {
+      it('should have a postWirelessControllerManagedDeviceGroupRadioProfileAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessControllerManagedDeviceGroupRadioProfileAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessControllerManagedDeviceGroupRadioProfileAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessControllerManagedDeviceGroupRadioProfileAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessControllerManagedDeviceGroupRadioProfileAssignments - errors', () => {
+      it('should have a putWirelessControllerManagedDeviceGroupRadioProfileAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessControllerManagedDeviceGroupRadioProfileAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessControllerManagedDeviceGroupRadioProfileAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessControllerManagedDeviceGroupRadioProfileAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessControllerManagedDeviceGroupRadioProfileAssignments - errors', () => {
+      it('should have a patchWirelessControllerManagedDeviceGroupRadioProfileAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessControllerManagedDeviceGroupRadioProfileAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchWirelessControllerManagedDeviceGroupRadioProfileAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessControllerManagedDeviceGroupRadioProfileAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessControllerManagedDeviceGroupRadioProfileAssignments - errors', () => {
+      it('should have a deleteWirelessControllerManagedDeviceGroupRadioProfileAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessControllerManagedDeviceGroupRadioProfileAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteWirelessControllerManagedDeviceGroupRadioProfileAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessControllerManagedDeviceGroupRadioProfileAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId - errors', () => {
+      it('should have a getWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId - errors', () => {
+      it('should have a putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId - errors', () => {
+      it('should have a patchWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId - errors', () => {
+      it('should have a deleteWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessControllerManagedDeviceGroupRadioProfileAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessControllerManagedDeviceGroupWirelessNetworkAssignments - errors', () => {
+      it('should have a getWirelessControllerManagedDeviceGroupWirelessNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessControllerManagedDeviceGroupWirelessNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessControllerManagedDeviceGroupWirelessNetworkAssignments - errors', () => {
+      it('should have a postWirelessControllerManagedDeviceGroupWirelessNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessControllerManagedDeviceGroupWirelessNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessControllerManagedDeviceGroupWirelessNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessControllerManagedDeviceGroupWirelessNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessControllerManagedDeviceGroupWirelessNetworkAssignments - errors', () => {
+      it('should have a putWirelessControllerManagedDeviceGroupWirelessNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessControllerManagedDeviceGroupWirelessNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessControllerManagedDeviceGroupWirelessNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessControllerManagedDeviceGroupWirelessNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignments - errors', () => {
+      it('should have a patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignments - errors', () => {
+      it('should have a deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignments('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId - errors', () => {
+      it('should have a getWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId - errors', () => {
+      it('should have a putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId - errors', () => {
+      it('should have a patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId - errors', () => {
+      it('should have a deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessControllerManagedDeviceGroupWirelessNetworkAssignmentsId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessRadioProfiles - errors', () => {
+      it('should have a getWirelessRadioProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessRadioProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessRadioProfiles - errors', () => {
+      it('should have a postWirelessRadioProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessRadioProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessRadioProfiles('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessRadioProfiles', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessRadioProfiles - errors', () => {
+      it('should have a putWirelessRadioProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessRadioProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessRadioProfiles('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessRadioProfiles', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessRadioProfiles - errors', () => {
+      it('should have a patchWirelessRadioProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessRadioProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchWirelessRadioProfiles('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessRadioProfiles', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessRadioProfiles - errors', () => {
+      it('should have a deleteWirelessRadioProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessRadioProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteWirelessRadioProfiles('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessRadioProfiles', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessRadioProfilesId - errors', () => {
+      it('should have a getWirelessRadioProfilesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessRadioProfilesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessRadioProfilesId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessRadioProfilesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessRadioProfilesId - errors', () => {
+      it('should have a putWirelessRadioProfilesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessRadioProfilesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putWirelessRadioProfilesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessRadioProfilesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessRadioProfilesId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessRadioProfilesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessRadioProfilesId - errors', () => {
+      it('should have a patchWirelessRadioProfilesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessRadioProfilesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchWirelessRadioProfilesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessRadioProfilesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessRadioProfilesId - errors', () => {
+      it('should have a deleteWirelessRadioProfilesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessRadioProfilesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteWirelessRadioProfilesId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessRadioProfilesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessRadioProfilesIdNotes - errors', () => {
+      it('should have a getWirelessRadioProfilesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessRadioProfilesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessRadioProfilesIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessRadioProfilesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessRadioProfilesIdNotes - errors', () => {
+      it('should have a postWirelessRadioProfilesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessRadioProfilesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postWirelessRadioProfilesIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessRadioProfilesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessRadioProfilesIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessRadioProfilesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessSupportedDataRates - errors', () => {
+      it('should have a getWirelessSupportedDataRates function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessSupportedDataRates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessSupportedDataRates - errors', () => {
+      it('should have a postWirelessSupportedDataRates function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessSupportedDataRates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessSupportedDataRates('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessSupportedDataRates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessSupportedDataRates - errors', () => {
+      it('should have a putWirelessSupportedDataRates function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessSupportedDataRates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessSupportedDataRates('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessSupportedDataRates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessSupportedDataRates - errors', () => {
+      it('should have a patchWirelessSupportedDataRates function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessSupportedDataRates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchWirelessSupportedDataRates('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessSupportedDataRates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessSupportedDataRates - errors', () => {
+      it('should have a deleteWirelessSupportedDataRates function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessSupportedDataRates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteWirelessSupportedDataRates('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessSupportedDataRates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessSupportedDataRatesId - errors', () => {
+      it('should have a getWirelessSupportedDataRatesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessSupportedDataRatesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessSupportedDataRatesId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessSupportedDataRatesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessSupportedDataRatesId - errors', () => {
+      it('should have a putWirelessSupportedDataRatesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessSupportedDataRatesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putWirelessSupportedDataRatesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessSupportedDataRatesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessSupportedDataRatesId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessSupportedDataRatesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessSupportedDataRatesId - errors', () => {
+      it('should have a patchWirelessSupportedDataRatesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessSupportedDataRatesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchWirelessSupportedDataRatesId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessSupportedDataRatesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessSupportedDataRatesId - errors', () => {
+      it('should have a deleteWirelessSupportedDataRatesId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessSupportedDataRatesId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteWirelessSupportedDataRatesId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessSupportedDataRatesId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessSupportedDataRatesIdNotes - errors', () => {
+      it('should have a getWirelessSupportedDataRatesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessSupportedDataRatesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessSupportedDataRatesIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessSupportedDataRatesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessSupportedDataRatesIdNotes - errors', () => {
+      it('should have a postWirelessSupportedDataRatesIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessSupportedDataRatesIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postWirelessSupportedDataRatesIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessSupportedDataRatesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessSupportedDataRatesIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessSupportedDataRatesIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessWirelessNetworks - errors', () => {
+      it('should have a getWirelessWirelessNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessWirelessNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessWirelessNetworks - errors', () => {
+      it('should have a postWirelessWirelessNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessWirelessNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessWirelessNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessWirelessNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessWirelessNetworks - errors', () => {
+      it('should have a putWirelessWirelessNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessWirelessNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessWirelessNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessWirelessNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessWirelessNetworks - errors', () => {
+      it('should have a patchWirelessWirelessNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessWirelessNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.patchWirelessWirelessNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessWirelessNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessWirelessNetworks - errors', () => {
+      it('should have a deleteWirelessWirelessNetworks function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessWirelessNetworks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteWirelessWirelessNetworks('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessWirelessNetworks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessWirelessNetworksId - errors', () => {
+      it('should have a getWirelessWirelessNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessWirelessNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessWirelessNetworksId('fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessWirelessNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#putWirelessWirelessNetworksId - errors', () => {
+      it('should have a putWirelessWirelessNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putWirelessWirelessNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.putWirelessWirelessNetworksId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessWirelessNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.putWirelessWirelessNetworksId('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-putWirelessWirelessNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#patchWirelessWirelessNetworksId - errors', () => {
+      it('should have a patchWirelessWirelessNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchWirelessWirelessNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.patchWirelessWirelessNetworksId('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-patchWirelessWirelessNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#deleteWirelessWirelessNetworksId - errors', () => {
+      it('should have a deleteWirelessWirelessNetworksId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteWirelessWirelessNetworksId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteWirelessWirelessNetworksId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-deleteWirelessWirelessNetworksId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getWirelessWirelessNetworksIdNotes - errors', () => {
+      it('should have a getWirelessWirelessNetworksIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWirelessWirelessNetworksIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getWirelessWirelessNetworksIdNotes('fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-getWirelessWirelessNetworksIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#postWirelessWirelessNetworksIdNotes - errors', () => {
+      it('should have a postWirelessWirelessNetworksIdNotes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postWirelessWirelessNetworksIdNotes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.postWirelessWirelessNetworksIdNotes('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessWirelessNetworksIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postWirelessWirelessNetworksIdNotes('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-nautobot_v2-adapter-postWirelessWirelessNetworksIdNotes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+    describe('#getMetrics - errors', () => {
+      it('should have a getMetrics function', (done) => {
+        try {
+          assert.equal(true, typeof a.getMetrics === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });