mongodb-atlas-api-client 3.21.0 → 4.0.2

package/test/atlasUser.test.js

@@ -1,12 +1,12 @@
-const {describe, it} = exports.lab = require("@hapi/lab").script();
-const {expect} = require("@hapi/code");
-const nock = require("nock");
-const getClient = require("../src");
-const AtlasUser = require("../src/atlasUser");
-const HttpClient = require("../src/httpClient");
-const sinon = require("sinon");
-
-const baseUrl = "http://dummyBaseUrl";
+const {describe, it, afterEach, before, beforeEach} = exports.lab = require("@hapi/lab").script();
+const {expect} = require('@hapi/code');
+const getClient = require('../src/index.js');
+const AtlasUser = require('../src/atlasUser.js');
+const HttpClient = require('../src/httpClient.js');
+const {stub} = require("sinon");
+const {MockAgent, setGlobalDispatcher} = require('urllib');
+
+const baseUrl = "http://localhost:7001";
 const projectId = "dummyProjectId";
 
 const client = getClient({
@@ -18,6 +18,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - Atlas User", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When atlasUser is exported from index", () => {
     it("should export atlasUser functions", async () => {
       expect(client.atlasUser.getById).to.be.function();
@@ -30,56 +45,63 @@ describe("Mongo Atlas Api Client - Atlas User", () => {
 
   describe("When getByName is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/users/byName/myuser?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/users/byName/myuser?key1=value1&key2=value2",
+        "method": "get"
+      })
         .reply(200, {"user": "name"});
       const result = await client.atlasUser.getByName("myuser", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"user": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
     });
   });
 
   describe("When getById is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/users/someid?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/users/someid?key1=value1&key2=value2",
+        "method": "get"
+      })
         .reply(200, {"user": "name"});
       const result = await client.atlasUser.getById("someid", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"user": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
     });
   });
 
   describe("When getAll is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/users?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/users?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, [{"user": "name"}]);
       const result = await client.atlasUser.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"user": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
     });
   });
 
   describe("When update is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .patch("/users/someId?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/users/someId?key1=value1&key2=value2",
+        "method": "PATCH",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"user": "name"}]);
       const result = await client.atlasUser.update("someId", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"user": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
     });
   });
 
   describe("When create is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post("/users?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/users?key1=value1&key2=value2",
+        "method": "POST",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"user": "name"}]);
       const result = await client.atlasUser.create({"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"user": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
     });
   });
 });
@@ -87,7 +109,7 @@ describe("Mongo Atlas Api Client - Atlas User", () => {
 describe("AtlasUser Class", () => {
 
   const mockRequest = {
-    "request": sinon.stub().returns(new Promise(resolve => resolve({"data": "some test data"})))
+    "request": stub().returns(new Promise(resolve => resolve({"data": "some test data"})))
   };
   const mockHttpClient = new HttpClient(mockRequest, "dummyPublicKey", "dummyPrivateKey");
 

package/test/cloudProviderAccess.test.js

@@ -1,9 +1,9 @@
-const {describe, it} = exports.lab = require("@hapi/lab").script();
-const {expect} = require("@hapi/code");
-const nock = require("nock");
-const getClient = require("../src");
+const {describe, it, afterEach, before, beforeEach} = exports.lab = require("@hapi/lab").script();
+const {expect} = require('@hapi/code');
+const getClient = require('../src/index.js');
+const {MockAgent, setGlobalDispatcher} = require('urllib');
 
-const baseUrl = "http://dummyBaseUrl";
+const baseUrl = "http://localhost:7001";
 const projectId = "dummyProjectId";
 
 const client = getClient({
@@ -15,6 +15,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - cloudProviderAccess", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When cloudProviderAccess is exported from index", () => {
     it("should export cloudProviderAccess functions", async () => {
       expect(client.cloudProviderAccess.getAll).to.be.function();
@@ -26,45 +41,55 @@ describe("Mongo Atlas Api Client - cloudProviderAccess", () => {
 
   describe("When getAll is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/cloudProviderAccess?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/cloudProviderAccess?key1=value1&key2=value2`,
+        "method": "GET"
+      })
         .reply(200, [{"cloudProviderAccess": "name"}]);
       const result = await client.cloudProviderAccess.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cloudProviderAccess": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When update is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .patch(`/groups/${projectId}/cloudProviderAccess/roleId?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/cloudProviderAccess/roleId?key1=value1&key2=value2`,
+        "method": "PATCH",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"cloudProviderAccess": "name"}]);
       const result = await client.cloudProviderAccess.update("roleId", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cloudProviderAccess": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When create is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post(`/groups/${projectId}/cloudProviderAccess?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/cloudProviderAccess?key1=value1&key2=value2`,
+        "method": "POST",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"cloudProviderAccess": "name"}]);
       const result = await client.cloudProviderAccess.create({"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cloudProviderAccess": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When delete is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .delete(`/groups/${projectId}/cloudProviderAccess/aws/roleId?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/cloudProviderAccess/aws/roleId?key1=value1&key2=value2`,
+        "method": "DELETE"
+      })
         .reply(200, true);
       const result = await client.cloudProviderAccess.delete("aws", "roleId", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });

package/test/cloudbackup.test.js

@@ -1,9 +1,9 @@
-const {describe, it} = exports.lab = require("@hapi/lab").script();
-const {expect} = require("@hapi/code");
-const nock = require("nock");
-const getClient = require("../src");
+const {describe, it, afterEach, before, beforeEach} = exports.lab = require("@hapi/lab").script();
+const {expect} = require('@hapi/code');
+const getClient = require('../src/index.js');
+const {MockAgent, setGlobalDispatcher} = require('urllib');
 
-const baseUrl = "http://dummyBaseUrl";
+const baseUrl = "http://localhost:7001";
 const projectId = "dummyProjectId";
 
 const client = getClient({
@@ -15,6 +15,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - CloudBackup", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When cluster is exported from index", () => {
     it("should export cluster functions", async () => {
       expect(client.cloudBackup.getReplicaSetCloudBackup).to.be.function();
@@ -26,45 +41,54 @@ describe("Mongo Atlas Api Client - CloudBackup", () => {
 
   describe("When getReplicaSetCloudBackup is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/clusters/mycluster/backup/snapshots/mysnapshot?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster/backup/snapshots/mysnapshot?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, {"replicaSetName": "mycluster"});
       const result = await client.cloudBackup.getReplicaSetCloudBackup("mycluster", "mysnapshot", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"replicaSetName": "mycluster"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAllReplicaSetCloudBackups is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/clusters/mycluster/backup/snapshots?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster/backup/snapshots?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, [{"replicaSetName": "mycluster"}]);
       const result = await client.cloudBackup.getAllReplicaSetCloudBackups("mycluster", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"replicaSetName": "mycluster"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getSnapshotRestoreJob is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/clusters/mycluster/backup/restoreJobs/myrestorejob?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster/backup/restoreJobs/myrestorejob?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, {"id": "myrestorejob"});
       const result = await client.cloudBackup.getSnapshotRestoreJob("mycluster", "myrestorejob", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"id": "myrestorejob"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When createSnapshotRestoreJob is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post(`/groups/${projectId}/clusters/mycluster/backup/restoreJobs?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster/backup/restoreJobs?key1=value1&key2=value2`,
+        "method": "post",
+        "data": {"body": "value"}
+      })
         .reply(200, {"id": "myrestorejob"});
       const result = await client.cloudBackup.createSnapshotRestoreJob("mycluster", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"id": "myrestorejob"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });

package/test/cluster.test.js

@@ -1,9 +1,9 @@
-const {describe, it} = exports.lab = require("@hapi/lab").script();
-const {expect} = require("@hapi/code");
-const nock = require("nock");
-const getClient = require("../src");
+const {describe, it, afterEach, before, beforeEach} = exports.lab = require("@hapi/lab").script();
+const {expect} = require('@hapi/code');
+const getClient = require('../src/index.js');
+const {MockAgent, setGlobalDispatcher} = require('urllib');
 
-const baseUrl = "http://dummyBaseUrl";
+const baseUrl = "http://localhost:7001";
 const projectId = "dummyProjectId";
 
 const client = getClient({
@@ -15,6 +15,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - Cluster", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When cluster is exported from index", () => {
     it("should export cluster functions", async () => {
       expect(client.cluster.get).to.be.function();
@@ -30,89 +45,109 @@ describe("Mongo Atlas Api Client - Cluster", () => {
 
   describe("When get is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/clusters/mycluster?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, {"cluster": "name"});
       const result = await client.cluster.get("mycluster", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"cluster": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAdvanceConfiguration is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/clusters/mycluster/processArgs?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster/processArgs?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, {"cluster": "name"});
       const result = await client.cluster.getAdvanceConfiguration("mycluster", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"cluster": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAll is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/clusters?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, [{"cluster": "name"}]);
       const result = await client.cluster.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cluster": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When update is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .patch(`/groups/${projectId}/clusters/myCluster?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/myCluster?key1=value1&key2=value2`,
+        "method": "patch",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"cluster": "name"}]);
       const result = await client.cluster.update("myCluster", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cluster": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When updateAdvanceConfiguration is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .patch(`/groups/${projectId}/clusters/myCluster/processArgs?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/myCluster/processArgs?key1=value1&key2=value2`,
+        "method": "patch",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"cluster": "name"}]);
       const result = await client.cluster.updateAdvanceConfiguration("myCluster", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cluster": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When create is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post(`/groups/${projectId}/clusters?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters?key1=value1&key2=value2`,
+        "method": "post",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"cluster": "name"}]);
       const result = await client.cluster.create({"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cluster": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When testPrimaryFailOver is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post(`/groups/${projectId}/clusters/mycluster/restartPrimaries?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster/restartPrimaries?key1=value1&key2=value2`,
+        "method": "post",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"cluster": "name"}]);
       const result = await client.cluster.testPrimaryFailOver("mycluster", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"cluster": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When delete is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .delete(`/groups/${projectId}/clusters/mycluster?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/clusters/mycluster?key1=value1&key2=value2`,
+        "method": "delete"
+      })
         .reply(200, true);
       const result = await client.cluster.delete("mycluster", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });

package/test/customDbRole.test.js

@@ -1,9 +1,9 @@
-const {describe, it} = exports.lab = require("@hapi/lab").script();
-const {expect} = require("@hapi/code");
-const nock = require("nock");
-const getClient = require("../src");
+const {describe, it, afterEach, before, beforeEach} = exports.lab = require("@hapi/lab").script();
+const {expect} = require('@hapi/code');
+const getClient = require('../src/index.js');
+const {MockAgent, setGlobalDispatcher} = require('urllib');
 
-const baseUrl = "http://dummyBaseUrl";
+const baseUrl = "http://localhost:7001";
 const projectId = "dummyProjectId";
 
 const client = getClient({
@@ -15,6 +15,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - Custom Db Role", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When customDbRole is exported from index", () => {
     it("should export customDbRole functions", async () => {
       expect(client.customDbRole.get).to.be.function();
@@ -27,56 +42,68 @@ describe("Mongo Atlas Api Client - Custom Db Role", () => {
 
   describe("When get is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/customDBRoles/roles/rolename?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/customDBRoles/roles/rolename?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, {"customDbRole": "name"});
       const result = await client.customDbRole.get("rolename", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"customDbRole": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAll is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/customDBRoles/roles?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/customDBRoles/roles?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, [{"customDbRole": "name"}]);
       const result = await client.customDbRole.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"customDbRole": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When update is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .patch(`/groups/${projectId}/customDBRoles/roles/rolename?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/customDBRoles/roles/rolename?key1=value1&key2=value2`,
+        "method": "PATCH",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"customDbRole": "name"}]);
       const result = await client.customDbRole.update("rolename", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"customDbRole": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When delete is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .delete(`/groups/${projectId}/customDBRoles/roles/rolename?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/customDBRoles/roles/rolename?key1=value1&key2=value2`,
+        "method": "delete"
+      })
         .reply(200, true);
       const result = await client.customDbRole.delete("rolename", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When create is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post(`/groups/${projectId}/customDBRoles/roles?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/customDBRoles/roles?key1=value1&key2=value2`,
+        "method": "post",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"customDbRole": "name"}]);
       const result = await client.customDbRole.create({"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"customDbRole": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });