Merge pull request #23 from tago-io/feat/unit-test-sdk

adding unit tests for sdk types

packages/tcore-sdk/src/Types/Account/Account.types.test.ts

@@ -0,0 +1,128 @@
+import { ZodError } from "zod";
+import { zAccountList, zAccountCreate, zAccountTokenCreate, zAccountListQuery } from "./Account.types";
+
+describe("zAccountList", () => {
+  test("parses simple object", () => {
+    const data = [
+      {
+        password: "password",
+        id: "id",
+      },
+    ];
+    const parsed = zAccountList.parse(data);
+    expect(parsed[0].id).toEqual("id");
+  });
+
+  test("check required field", () => {
+    const data = [
+      {
+        password: "password",
+      },
+    ];
+    try {
+      zAccountList.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.id).toBe(undefined);
+    }
+  });
+
+  test("assure it is an array", () => {
+    const data = {
+      password: "password",
+      id: "id",
+    };
+    try {
+      zAccountList.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors).toStrictEqual({});
+    }
+  });
+});
+
+describe("zAccountListQuery", () => {
+  test("parses simple object", () => {
+    const data = {
+      fields: ["id"],
+    };
+    const parsed = zAccountListQuery.parse(data);
+    expect(parsed.fields[0]).toEqual("id");
+  });
+
+  test("error if invalid option", () => {
+    const data = {
+      fields: [" "],
+    };
+    try {
+      zAccountListQuery.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.fields[0].startsWith("Invalid enum value.")).toBeTruthy();
+    }
+  });
+
+  test("assure empty query", () => {
+    const data = {
+      fields: [],
+    };
+    const parsed = zAccountListQuery.parse(data);
+    expect(parsed.fields).toContain("id");
+  });
+});
+
+describe("zAccountCreate", () => {
+  test("parses simple object", () => {
+    const data = {
+      name: "name",
+      username: "username",
+      password: "password",
+    };
+    const parsed = zAccountCreate.parse(data);
+    expect(parsed.name).toEqual("name");
+  });
+
+  test("assure assignment of implicit fields", () => {
+    const data = {
+      name: "name",
+      username: "username",
+      password: "password",
+    };
+    const parsed = zAccountCreate.parse(data);
+    expect(parsed.created_at).toBeInstanceOf(Date);
+    expect(parsed.id).toEqual(expect.any(String));
+    expect(parsed.password_hint).toBeUndefined();
+  });
+});
+
+describe("zAccountTokenCreate", () => {
+  test("parses simple object", () => {
+    const data = {
+      permission: "full",
+    };
+    const parsed = zAccountTokenCreate.parse(data);
+    expect(parsed.permission).toEqual("full");
+  });
+
+  test("error if invalid option", () => {
+    const data = {
+      permission: " ",
+    };
+    try {
+      zAccountTokenCreate.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.permission[0].startsWith("Invalid enum value.")).toBeTruthy();
+    }
+  });
+
+  test("assure assignment of implicit fields", () => {
+    const data = {
+      permission: "full",
+    };
+    const parsed = zAccountTokenCreate.parse(data);
+    expect(parsed.created_at).toBeInstanceOf(Date);
+    expect(parsed.token).toEqual(expect.any(String));
+    expect(parsed.expire_time).toEqual("1 month");
+  });
+});

packages/tcore-sdk/src/Types/Action/Action.types.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { generateResourceID } from "../../Shared/ResourceID";
-import { IPluginConfigField, zPluginModuleIDCombo } from "../Plugin.types";
+import { IPluginConfigField, zPluginModuleIDCombo } from "../Plugin/Plugin.types";
 import { zQuery, zName, zObjectID, zActiveAutoGen, zTagsAutoGen } from "../Common/Common.types";
-import { zTags } from "../Tag.types";
+import { zTags } from "../Tag/Tag.types";
 import preprocessBoolean from "../Helpers/preprocessBoolean";
 import preprocessObject from "../Helpers/preprocessObject";
 import removeNullValues from "../Helpers/removeNullValues";

packages/tcore-sdk/src/Types/Analysis/Analysis.types.ts

@@ -8,8 +8,8 @@ import {
   zQuery,
   zObjectIDAutoGen,
 } from "../Common/Common.types";
-import { zTags } from "../Tag.types";
-import { zLog } from "../Log.types";
+import { zTags } from "../Tag/Tag.types";
+import { zLog } from "../Log/Log.types";
 import preprocessBoolean from "../Helpers/preprocessBoolean";
 import preprocessObject from "../Helpers/preprocessObject";
 import createQueryOrderBy from "../Helpers/createQueryOrderBy";

packages/tcore-sdk/src/Types/Common/Common.types.ts

@@ -3,8 +3,8 @@ import { DateTime } from "luxon";
 import cronParser from "cron-parser";
 import preprocessNumber from "../Helpers/preprocessNumber";
 import { generateResourceID } from "../../Shared/ResourceID";
-import { zTag } from "../Tag.types";
-import { parseSafe } from "../Helpers";
+import { zTag } from "../Tag/Tag.types";
+import { parseSafe } from "../Helpers/parseSafe";
 import createQueryOrderBy from "../Helpers/createQueryOrderBy";
 import { parseRelativeDate } from "../Helpers/parseRelativeDate";
 

packages/tcore-sdk/src/Types/Device/Device.types.ts

@@ -4,7 +4,7 @@ import preprocessObject from "../Helpers/preprocessObject";
 import preprocessBoolean from "../Helpers/preprocessBoolean";
 import removeNullValues from "../Helpers/removeNullValues";
 import { generateResourceID } from "../../Shared/ResourceID";
-import { zTags } from "../Tag.types";
+import { zTags } from "../Tag/Tag.types";
 import { zToken, TGenericID, zName, zObjectID, zQuery, zActiveAutoGen, zTagsAutoGen } from "../Common/Common.types";
 import createQueryOrderBy from "../Helpers/createQueryOrderBy";
 import preprocessNumber from "../Helpers/preprocessNumber";

packages/tcore-sdk/src/Types/Hardware/Hardware.types.test.ts

@@ -0,0 +1,127 @@
+import { ZodError } from "zod";
+import { zOSInfo, zNetworkInfo, zComputerUsage } from "./Hardware.types";
+
+describe("zOSInfo", () => {
+  test("parses simple object", () => {
+    const data = {
+      version: "version",
+      arch: "arch",
+      name: "name",
+      code: "linux",
+      hardware: "hardware",
+      hostname: "hostname",
+    };
+    const parsed = zOSInfo.parse(data);
+    expect(parsed.version).toEqual("version");
+  });
+
+  test("check required fields", () => {
+    const data = {
+      version: "version",
+    };
+    try {
+      zOSInfo.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.arch[0]).toBe("Required");
+    }
+  });
+
+  test("error if invalid code", () => {
+    const data = {
+      version: "version",
+      arch: "arch",
+      name: "name",
+      code: " ",
+      hardware: "hardware",
+      hostname: "hostname",
+    };
+    try {
+      zOSInfo.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.code[0].startsWith("Invalid enum value.")).toBeTruthy();
+    }
+  });
+});
+
+describe("zNetworkInfo", () => {
+  test("parses simple object", () => {
+    const data = {
+      name: "name",
+      ip: "ip",
+      bytesTransferred: 0,
+      bytesDropped: 0,
+    };
+    const parsed = zNetworkInfo.parse(data);
+    expect(parsed.name).toEqual("name");
+  });
+
+  test("check required fields", () => {
+    const data = {
+      name: "name",
+    };
+    try {
+      zNetworkInfo.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.ip[0]).toBe("Required");
+    }
+  });
+
+  test("assure correct field types", () => {
+    const data = {
+      name: "name",
+      ip: 0,
+      bytesTransferred: "bytesTransferred",
+      bytesDropped: 0,
+    };
+    try {
+      zNetworkInfo.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.ip[0]).toBe("Expected string, received number");
+    }
+  });
+});
+
+describe("zComputerUsage", () => {
+  test("parses simple object", () => {
+    const data = {
+      description: "string", // undefined
+      detail: "detail", // undefined
+      type: "type",
+      total: 0,
+      used: 1,
+      title: "title",
+    };
+    const parsed = zComputerUsage.parse(data);
+    expect(parsed.type).toEqual("type");
+  });
+
+  test("check required fields", () => {
+    const data = {
+      description: "string", // undefined
+      detail: "detail", // undefined
+      type: "type",
+    };
+    try {
+      zComputerUsage.parse(data);
+    } catch (error) {
+      const e = (error as ZodError).flatten();
+      expect(e.fieldErrors.title[0]).toBe("Required");
+    }
+  });
+
+  test("parses without optional fields", () => {
+    const data = {
+      type: "type",
+      total: 0,
+      used: 1,
+      title: "title",
+    };
+    const parsed = zComputerUsage.parse(data);
+    expect(parsed.description).toBeUndefined();
+    expect(parsed.detail).toBeUndefined();
+  });
+});

packages/tcore-sdk/src/Types/Helpers/parseRelativeDate.test.ts

@@ -0,0 +1,18 @@
+import { convertDateToISO, parseRelativeDate } from "./parseRelativeDate";
+
+describe("convertDateToISO", () => {
+  test("convert simple date", () => {
+    const data = convertDateToISO("01/01/01");
+    expect(typeof data).toBe("string");
+  });
+});
+
+describe("parseRelativeDate", () => {
+  test("check invalid date", () => {
+    try {
+      parseRelativeDate(" ", " ");
+    } catch (e: any) {
+      expect(e.message).toBe("Invalid date");
+    }
+  });
+});

packages/tcore-sdk/src/Types/Helpers/parseSafe.test.ts

@@ -0,0 +1,15 @@
+import { parseSafe } from "./parseSafe";
+
+describe("parseSafe", () => {
+  test("assure correct parsing", () => {
+    const data = '{"value":1}';
+    const process = parseSafe(data);
+    expect(process).toStrictEqual({ value: 1 });
+  });
+
+  test("exception catching", () => {
+    const data = 0;
+    const process = parseSafe(data);
+    expect(process).toStrictEqual({});
+  });
+});

packages/tcore-sdk/src/Types/Helpers/parseSafe.ts

@@ -0,0 +1,14 @@
+/**
+ * Parses a JSON safely.
+ */
+export function parseSafe(value: any, fallback: any = {}) {
+  try {
+    if (value && typeof value === "object") {
+      return value;
+    }
+    const result = JSON.parse(value);
+    return result || fallback;
+  } catch (ex) {
+    return fallback;
+  }
+}

packages/tcore-sdk/src/Types/Helpers/preprocessBoolean.test.ts

@@ -0,0 +1,22 @@
+import preprocessBoolean from "./preprocessBoolean";
+
+describe("preprocessBoolean", () => {
+  test("process standard boolean", () => {
+    const data = true;
+    const process = preprocessBoolean(data);
+    expect(process).toEqual(data);
+  });
+
+  test("process literal boolean", () => {
+    const data = "true";
+    const process = preprocessBoolean(data);
+    expect(typeof process).toBe("boolean");
+    expect(process).toEqual(true);
+  });
+
+  test("return true", () => {
+    const data = "0";
+    const process = preprocessBoolean(data);
+    expect(process).toBeTruthy();
+  });
+});

packages/tcore-sdk/src/Types/Helpers/preprocessNumber.test.ts

@@ -0,0 +1,17 @@
+import preprocessNumber from "./preprocessNumber";
+
+describe("preprocessNumber", () => {
+  test("process string param", () => {
+    const data = "123";
+    const process = preprocessNumber(data);
+    expect(typeof process).toBe("number");
+    expect(process).toEqual(123);
+  });
+
+  test("filter booleans values", () => {
+    const data = true;
+    const process = preprocessNumber(data);
+    expect(typeof process).toBe("string");
+    expect(process).toEqual("");
+  });
+});