CI: use native tests from node 18

Author: dubisdev

.github/workflows/release_manager.yml

@@ -13,7 +13,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
       - name: Installing project dependencies
         run: yarn
       - name: Running tests
@@ -32,7 +32,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
       - run: yarn install
       - run: yarn prepublish
 

.github/workflows/tests.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
       - name: Installing project dependencies
         run: yarn
       - name: Running tests

jest.config.mjs

@@ -18,17 +18,14 @@
     "uuid": "8.3.2"
   },
   "devDependencies": {
-    "@types/jest": "27.4.1",
     "@types/uuid": "8.3.4",
     "@types/node": "17.0.25",
     "dotenv": "10.0.0",
-    "jest": "27.5.1",
-    "ts-jest": "27.1.4",
     "typescript": "4.6.3"
   },
   "scripts": {
     "prepublish": "tsc",
-    "test": "jest"
+    "test": "tsc && node ./src/__tests__/index.js"
   },
   "repository": {
     "type": "git",

package.json

@@ -0,0 +1,17 @@
+import TDSClient from "../../dist/index.js";
+import test from "node:test";
+import assert from "node:assert";
+
+test("Module importing and Client initialization", async (t) => {
+  await t.test("Correctly imported and exported", () => {
+    assert.strictEqual(typeof TDSClient, "function");
+  });
+
+  await t.test("Throw error when no token", () => {
+    assert.throws(TDSClient);
+  });
+
+  await t.test("Create client when token exists", () => {
+    assert.doesNotThrow(() => TDSClient("token"));
+  });
+});

src/__tests__/client.tests.js

@@ -0,0 +1,99 @@
+import test from "node:test";
+import assert from "node:assert";
+
+import TDSClient, { Comment } from "../../dist/index.js";
+
+const myClient = TDSClient(process.env.TODOIST_TOKEN);
+
+// get the inbox project id
+let inboxProjectID;
+
+inboxProjectID =
+  (await myClient.project.getAll()).find((project) => project.inbox_project)
+    ?.id || 0;
+
+await test("Client-Side Comment Creation", async (t) => {
+  await t.test("Create Empty Comment", () => {
+    const emptyComment = Comment({ task_id: 123456 });
+    assert.deepStrictEqual(emptyComment, {
+      content: "_No_Content_Provided_",
+      task_id: 123456,
+    });
+  });
+
+  await t.test("Create Normal Comment", () => {
+    let myComment = Comment({ content: "Test Content", task_id: 123456 });
+    assert.deepStrictEqual(myComment, {
+      content: "Test Content",
+      task_id: 123456,
+    });
+  });
+});
+
+await test("API Comment Functions", async (t) => {
+  let commentID;
+
+  await t.test("Create A Comment", async () => {
+    let apiComment = await myClient.comment.create({
+      content: "This is the content",
+      project_id: inboxProjectID,
+    });
+
+    assert(apiComment.id);
+
+    commentID = apiComment.id;
+  });
+
+  await t.test("Get A Comment", async () => {
+    let apiComment = await myClient.comment.get(commentID);
+
+    assert.deepStrictEqual(apiComment.content, "This is the content");
+  });
+
+  await t.test("Create Two More Comments", async () => {
+    return await Promise.all([
+      await myClient.comment.create({
+        content: "Comment 2",
+        project_id: inboxProjectID,
+      }),
+      await myClient.comment.create({
+        content: "Comment 3",
+        project_id: inboxProjectID,
+      }),
+    ]);
+  });
+
+  await t.test("Get All Comments", async () => {
+    const responseComments = await myClient.comment.getAll({
+      project_id: inboxProjectID,
+    });
+    const testCommmentExists = responseComments.some(
+      (commentObj) => commentObj.content === "This is the content"
+    );
+
+    assert(testCommmentExists);
+    assert(responseComments.length === 3);
+  });
+
+  await t.test("Update a comment", async () => {
+    const repsonse = await myClient.comment.update(commentID, {
+      content: "New content",
+    });
+
+    assert(repsonse.status === 204);
+  });
+
+  await t.test("Delete All Previous Comments", async () => {
+    let allCommentsJSON = await myClient.comment.getAll({
+      project_id: inboxProjectID,
+    });
+
+    let responses = await Promise.all(
+      allCommentsJSON.map(async (comment) =>
+        myClient.comment.delete(comment.id)
+      )
+    );
+
+    responses.forEach(({ status }) => assert(status === 204));
+  });
+});

src/__tests__/client.tests.ts

@@ -0,0 +1,8 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+await import("./client.tests.js");
+await import("./task.tests.js");
+await import("./projects.tests.js");
+await import("./labels.tests.js");
+await import("./comments.tests.js");

src/__tests__/comments.tests.js

@@ -0,0 +1,82 @@
+import test from "node:test";
+import assert from "node:assert";
+
+import TDSClient, { Label } from "../../dist/index.js";
+
+const myClient = TDSClient(process.env.TODOIST_TOKEN);
+
+await test("Client-Side Label Creation", async (t) => {
+  await t.test("Create Empty Label", () => {
+    const emptyLabel = Label();
+    assert.deepStrictEqual(emptyLabel, { name: "_No_Label_Name_Provided_" });
+  });
+
+  await t.test("Create Normal Label", () => {
+    let myLabel = Label({ name: "Label Name" });
+    assert.deepStrictEqual(myLabel, { name: "Label Name" });
+  });
+});
+
+await test("API Label Functions", async (t) => {
+  let labelID;
+
+  await t.test("Create A Label", async () => {
+    let apiLabel = await myClient.label.create({ name: "Test Label" });
+
+    assert(apiLabel.id);
+
+    labelID = apiLabel.id;
+  });
+
+  await t.test("Get A Label", async () => {
+    let apiLabel = await myClient.label.get(labelID);
+
+    assert.deepStrictEqual(apiLabel.name, "Test_Label");
+  });
+
+  // 2 active projects now
+  await t.test("Create Two More Labels", async () => {
+    return await Promise.all([
+      myClient.label.create({ name: "Label 2" }),
+      myClient.label.create({ name: "Label 3" }),
+    ]);
+  });
+
+  await t.test("Get All Labels", async () => {
+    const responseLabels = await myClient.label.getAll();
+    const testLabelExists = responseLabels.some(
+      (labelObj) => labelObj.name === "Test_Label"
+    );
+
+    assert(testLabelExists);
+    assert(responseLabels.length === 3);
+  });
+
+  await t.test("Get All Label Names", async () => {
+    const responseLabels = await myClient.extras.getAllLabelNames();
+    const testLabelExists = responseLabels.some(
+      (name) => name === "Test_Label"
+    );
+
+    assert(testLabelExists);
+    assert(responseLabels.length === 3);
+  });
+
+  await t.test("Update a label", async () => {
+    const response = await myClient.label.update(labelID, {
+      name: "New label name",
+    });
+
+    assert(response.status === 204);
+  });
+
+  await t.test("Delete All Previous Labels", async () => {
+    let allLabelsJSON = await myClient.label.getAll();
+
+    let responses = await Promise.all(
+      allLabelsJSON.map(async (label) => myClient.label.delete(label.id))
+    );
+
+    responses.forEach(({ status }) => assert(status === 204));
+  });
+});