@tomsd/mongodbclient 3.0.9 → 3.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomsd/mongodbclient",
-  "version": "3.0.9",
+  "version": "3.0.10",
   "description": "It's a handy mongodb client for easy-use.",
   "main": "dist/cjs/mongodbclient.js",
   "module": "dist/esm/mongodbclient.js",
@@ -15,8 +15,8 @@
     "lint:test": "eslint test/**/*.ts",
     "prepare": "husky install",
     "serve:doc": "mdbook --serve --directory docs",
-    "test": "exit 0",
-    "test_with_dburi": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register \"test/test.ts\" --timeout 30000"
+    "test": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register \"test/mclient.test.ts\" --timeout 30000",
+    "test_with_dburi": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register \"test/with_dburi.test.ts\" --timeout 30000"
   },
   "lint-staged": {
     "docs/**/*.html": [
@@ -48,6 +48,7 @@
     "@tomsd/md-book": "^0.16.0",
     "@types/mocha": "^9.1.1",
     "@types/node": "^14.14.5",
+    "@types/sinon": "^10.0.13",
     "@types/uuid": "^8.3.4",
     "@typescript-eslint/eslint-plugin": "^5.38.0",
     "dotenv": "^16.0.1",
@@ -61,6 +62,7 @@
     "lint-staged": "^13.0.3",
     "mocha": "^7.0.1",
     "prettier": "^2.7.1",
+    "sinon": "^14.0.0",
     "ts-node": "^10.8.1",
     "typescript": "^4.8.3"
   }

package/test/mclient.test.ts

@@ -0,0 +1,239 @@
+import { describe, it } from "mocha";
+import { MClient } from "../src/mongodbclient";
+import { strict as assert } from "assert";
+import { mock } from "sinon";
+
+const testConfig = {
+  uri: "mongodb+srv://...",
+  db: "db",
+  collection: "collection",
+};
+let mdbc: MClient;
+
+describe("MClient", () => {
+  before(() => {
+    mdbc = new MClient(testConfig.uri, testConfig.db, testConfig.collection);
+  });
+
+  it("property uri", () => {
+    assert.equal(mdbc.uri, testConfig.uri);
+  });
+
+  it("properti db", () => {
+    assert.equal(mdbc.db, testConfig.db);
+  });
+
+  it("property collection", () => {
+    assert.equal(mdbc.collection, testConfig.collection);
+  });
+
+  it("upsert()", async () => {
+    const connection = {
+      collection: {
+        updateOne: async (obj: any) =>
+          await Promise.resolve({
+            upsertedCount: 1,
+            modifiedCount: 0,
+          }),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+    const mocked = mock(mdbc);
+    mocked
+      .expects("getConnected")
+      .once()
+      .withArgs()
+      .returns(Promise.resolve(connection));
+
+    assert.equal(
+      await mdbc
+        .upsert({ name: "test" })
+        .then(({ upsertedCount }) => upsertedCount),
+      1
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("read()", async () => {
+    const returningDocuments = [{ name: "test" }];
+    const connection = {
+      collection: {
+        find: (condition: any) => ({
+          toArray: async () => await Promise.resolve(returningDocuments),
+        }),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+
+    const mocked = mock(mdbc);
+    mocked
+      .expects("getConnected")
+      .once()
+      .withArgs()
+      .returns(Promise.resolve(connection));
+
+    assert.equal(
+      JSON.stringify(await mdbc.read({ name: "test" })),
+      JSON.stringify(returningDocuments)
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("distinct()", async () => {
+    const returningValues = ["test1", "test2"];
+    const connection = {
+      collection: {
+        distinct: async (key: string) => await Promise.resolve(returningValues),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+    const mocked = mock(mdbc);
+    mocked
+      .expects("getConnected")
+      .once()
+      .withArgs()
+      .returns(Promise.resolve(connection));
+
+    assert.equal(
+      JSON.stringify(await mdbc.distinct("name")),
+      JSON.stringify(returningValues)
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("remove()", async () => {
+    const returningValue = { deletedCount: 1 };
+    const connection = {
+      collection: {
+        deleteMany: async (condition: any) =>
+          await Promise.resolve(returningValue),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+    const mocked = mock(mdbc);
+    mocked
+      .expects("getConnected")
+      .once()
+      .withArgs()
+      .returns(Promise.resolve(connection));
+
+    assert.equal(
+      JSON.stringify(await mdbc.remove({ name: "test" })),
+      JSON.stringify(returningValue)
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("stats()", async () => {
+    const returningValue = { storageSize: 100 };
+    const connection = {
+      collection: {
+        stats: async () => await Promise.resolve(returningValue),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+    const mocked = mock(mdbc);
+    mocked.expects("getConnected").once().withArgs().returns(connection);
+
+    assert.equal(
+      await mdbc.stats().then(({ storageSize }) => storageSize),
+      100
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("count()", async () => {
+    const resultValue = 100;
+    const connection = {
+      collection: {
+        countDocuments: async (condition: any) =>
+          await Promise.resolve(resultValue),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+    const mocked = mock(mdbc);
+    mocked.expects("getConnected").once().withArgs().returns(connection);
+
+    assert.equal(await mdbc.count({ name: "test" }), resultValue);
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("insertMany()", async () => {
+    const insertingItems = [
+      { name: "test1" },
+      { name: "test2" },
+      { name: "test3" },
+    ];
+    const connection = {
+      collection: {
+        insertMany: async (savingItems: any[]) =>
+          await Promise.resolve({
+            insertedCount: savingItems.length,
+          }),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+
+    const mocked = mock(mdbc);
+    mocked.expects("getConnected").once().withArgs().returns(connection);
+
+    assert.equal(
+      await mdbc
+        .insertMany(insertingItems)
+        .then(({ insertedCount }) => insertedCount),
+      insertingItems.length
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+
+  it("dbStats()", async () => {
+    const resultValue = { storageSize: 100 };
+    const connection = {
+      db: {
+        stats: async () => await Promise.resolve(resultValue),
+      },
+      client: {
+        close: () => undefined,
+      },
+    };
+
+    const mocked = mock(mdbc);
+    mocked.expects("getConnected").once().withArgs().returns(connection);
+
+    assert.equal(
+      await mdbc.dbStats().then(({ storageSize }) => storageSize),
+      100
+    );
+
+    mocked.verify();
+    mocked.restore();
+  });
+});