mongodb-atlas-api-client 3.21.0 → 4.0.2

package/test/dataLake.test.js

@@ -1,8 +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 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 {MockAgent, setGlobalDispatcher} = require('urllib');
+
+const baseUrl = "http://localhost:7001";
 const projectId = "dummyProjectId";
 
 const client = getClient({
@@ -14,6 +15,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - dataLake", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When dataLake is exported from index", () => {
     it("should export dataLake functions", async () => {
       expect(client.dataLake.get).to.be.function();
@@ -27,67 +43,81 @@ describe("Mongo Atlas Api Client - dataLake", () => {
 
   describe("When get is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/dataLakes/mydataLakename?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/dataLakes/mydataLakename?key1=value1&key2=value2`,
+        "method": "GET"
+      })
         .reply(200, {"datalake": "name"});
       const result = await client.dataLake.get("mydataLakename", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"datalake": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getLogsStream is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/dataLakes/mydataLakename/queryLogs.gz?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/dataLakes/mydataLakename/queryLogs.gz?key1=value1&key2=value2`,
+        "method": "GET"
+      })
         .reply(200, Buffer.from("Some test string", "utf8"), {"headers": {"accept": "application/gzip"}});
       const result = await client.dataLake.getLogsStream("mydataLakename", {"key1": "value1", "key2": "value2"});
       expect(result.pipe).to.exist();
-      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}/dataLakes?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/dataLakes?key1=value1&key2=value2`,
+        "method": "GET"
+      })
         .reply(200, [{"datalake": "name"}]);
       const result = await client.dataLake.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"datalake": "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}/dataLakes/mydataLakename?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/dataLakes/mydataLakename?key1=value1&key2=value2`,
+        "method": "PATCH",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"datalake": "name"}]);
       const result = await client.dataLake.update("mydataLakename", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"datalake": "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}/dataLakes?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/dataLakes?key1=value1&key2=value2`,
+        "method": "POST",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"dataLakes": "name"}]);
       const result = await client.dataLake.create({"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"dataLakes": "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}/dataLakes/mydataLakename?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/dataLakes/mydataLakename?key1=value1&key2=value2`,
+        "method": "DELETE"
+      })
         .reply(200, true);
       const result = await client.dataLake.delete("mydataLakename", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
-});
+});

package/test/event.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 - Event", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When event is exported from index", () => {
     it("should export event functions", async () => {
       expect(client.event.get).to.be.function();
@@ -26,45 +41,53 @@ describe("Mongo Atlas Api Client - Event", () => {
 
   describe("When get is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get(`/groups/${projectId}/events/myeventId?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/events/myeventId?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, {"event": "name"});
       const result = await client.event.get("myeventId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"event": "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}/events?key1=value1&key2=value2`)
+      mockPool.intercept({
+        "path": `/groups/${projectId}/events?key1=value1&key2=value2`,
+        "method": "get"
+      })
         .reply(200, [{"event": "name"}]);
       const result = await client.event.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"event": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getByOrganizationId is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/orgs/myOrgId/events/myeventId?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/myOrgId/events/myeventId?key1=value1&key2=value2",
+        "method": "get"
+      })
         .reply(200, {"event": "name"});
       const result = await client.event.getByOrganizationId("myOrgId", "myeventId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"event": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAllByOrganizationId is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/orgs/myOrgId/events?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/myOrgId/events?key1=value1&key2=value2",
+        "method": "get"
+      })
         .reply(200, [{"event": "name"}]);
       const result = await client.event.getAllByOrganizationId("myOrgId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"event": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });

package/test/helper.test.js

@@ -1,6 +1,6 @@
 const {describe, it} = exports.lab = require("@hapi/lab").script();
-const {expect} = require("@hapi/code");
-const {getQueryStringFromOptions} = require("../src/helper");
+const {expect} = require('@hapi/code');
+const {getQueryStringFromOptions}  = require('../src/helper.js');
 
 describe("Helper Methods", () => {
 

package/test/organization.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 client = getClient({
   "publicKey": "dummuyPublicKey",
@@ -13,6 +13,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - Organization", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When organization is exported from index", () => {
     it("should export organization functions", async () => {
       expect(client.organization.getById).to.be.function();
@@ -27,78 +42,94 @@ describe("Mongo Atlas Api Client - Organization", () => {
 
   describe("When getById is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/orgs/orgName?key1=value1&key2=value2")
-        .reply(200, {"organization": "name"});
+      mockPool.intercept({
+        "path": "/orgs/orgName",
+        "query": {"key1": "value1", "key2": "value2"},
+        "method": "GET"
+      }).reply(200, {"organization": "name"});
       const result = await client.organization.getById("orgName", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"organization": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAllUsersForOrganization is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/orgs/orgId/users?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/orgId/users?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, {"organization": "name"});
       const result = await client.organization.getAllUsersForOrganization("orgId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"organization": "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("/orgs?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, [{"organization": "name"}]);
       const result = await client.organization.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"organization": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When rename is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .patch("/orgs/orgId?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/orgId?key1=value1&key2=value2",
+        "method": "PATCH",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"organization": "name"}]);
       const result = await client.organization.rename("orgId", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"organization": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getAllProjectsForOrganization is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/orgs/orgId/groups?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/orgId/groups?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, [{"organization": "name"}]);
       const result = await client.organization.getAllProjectsForOrganization("orgId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"organization": "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("/orgs/orgId?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/orgId?key1=value1&key2=value2",
+        "method": "DELETE"
+      })
         .reply(200, true);
       const result = await client.organization.delete("orgId", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When invite is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post("/orgs/orgId/invites?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/orgs/orgId/invites?key1=value1&key2=value2",
+        "method": "POST",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"organization": "name"}]);
       const result = await client.organization.invite("orgId", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"organization": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });

package/test/project.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 client = getClient({
   "publicKey": "dummuyPublicKey",
@@ -13,6 +13,21 @@ const client = getClient({
 
 describe("Mongo Atlas Api Client - Project", () => {
 
+  let mockAgent;
+  let mockPool;
+  before(() => {
+    mockAgent = new MockAgent();
+    setGlobalDispatcher(mockAgent);
+  });
+
+  beforeEach(() => {
+    mockPool = mockAgent.get(baseUrl);
+  });
+
+  afterEach(() => {
+    mockAgent.assertNoPendingInterceptors();
+  });
+
   describe("When project is exported from index", () => {
     it("should export project functions", async () => {
       expect(client.project.getById).to.be.function();
@@ -28,89 +43,107 @@ describe("Mongo Atlas Api Client - Project", () => {
 
   describe("When getById is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/groups/projectId?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups/projectId?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, {"project": "name"});
       const result = await client.project.getById("projectId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"project": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getByName is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/groups/byName/projectName?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups/byName/projectName?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, {"project": "name"});
       const result = await client.project.getByName("projectName", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"project": "name"});
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When getTeamsByProjectId is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .get("/groups/projectId/teams?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups/projectId/teams?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, {"project": "name"});
       const result = await client.project.getTeamsByProjectId("projectId", {"key1": "value1", "key2": "value2"});
       expect(result).to.equal({"project": "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?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups?key1=value1&key2=value2",
+        "method": "GET"
+      })
         .reply(200, [{"project": "name"}]);
       const result = await client.project.getAll({"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"project": "name"}]);
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When assignTeams is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .post("/groups/projectId/teams?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups/projectId/teams?key1=value1&key2=value2",
+        "method": "POST",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"project": "name"}]);
       const result = await client.project.assignTeams("projectId", {"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"project": "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?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups?key1=value1&key2=value2",
+        "method": "POST",
+        "data": {"body": "value"}
+      })
         .reply(200, [{"project": "name"}]);
       const result = await client.project.create({"body": "value"}, {"key1": "value1", "key2": "value2"});
       expect(result).to.equal([{"project": "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?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups/projectId?key1=value1&key2=value2",
+        "method": "DELETE"
+      })
         .reply(200, true);
       const result = await client.project.delete("projectId", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 
   describe("When removeUserFromProject is called with querystring parameters", () => {
     it("should return response", async () => {
-      const expectedRequest = nock(baseUrl)
-        .delete("/groups/projectId/users/userId?key1=value1&key2=value2")
+      mockPool.intercept({
+        "path": "/groups/projectId/users/userId?key1=value1&key2=value2",
+        "method": "DELETE"
+      })
         .reply(200, true);
       const result = await client.project.removeUserFromProject("projectId", "userId", {"key1": "value1", "key2": "value2"});
       expect(result).to.be.true();
-      expect(expectedRequest.isDone()).to.be.true();
+
     });
   });
 });