feat: add unit tests for attribute parser, case, repeat, math

joplin · Nov 2, 2023 · 30eed04 · 30eed04
1 parent 72a3f39
commit 30eed04
Show file tree

Hide file tree

Showing 4 changed files with 439 additions and 7 deletions.
diff --git a/src/helpers/case.ts b/src/helpers/case.ts
@@ -2,7 +2,7 @@ import { HandlebarsHelper, HelperConstructorBlock } from "./helper";
 
 export const caseHelper: HelperConstructorBlock = ctx => {
     return new HandlebarsHelper("case", (type, rawV1): string => {
-        const v1 = new String(rawV1);
+        const v1 = new String(rawV1).toString();
 
         switch (type) {
             case "upper":

diff --git a/src/helpers/utils/attributes.ts b/src/helpers/utils/attributes.ts
@@ -11,7 +11,7 @@ export interface AttributeDefinition {
 }
 
 interface RawAttributes {
-    [attr: string]: string
+    [attr: string]: unknown
 }
 
 export interface ParsedAttributes {
@@ -21,19 +21,19 @@ export interface ParsedAttributes {
 export class AttributeParser {
     constructor(private schema: AttributeDefinition[]) {}
 
-    private parseAttribute(attr: AttributeDefinition, rawValue: string) {
+    private parseAttribute(attr: AttributeDefinition, rawValue: unknown) {
         switch (attr.valueType) {
             case AttributeValueType.Boolean:
-                return new Boolean(rawValue);
+                return !!rawValue;
             case AttributeValueType.Number: {
-                const v = Number.parseFloat(rawValue);
-                if (Number.isNaN(v)) {
+                const v = typeof rawValue === "string" ? Number.parseFloat(rawValue) : rawValue;
+                if (typeof v !== "number" || Number.isNaN(v)) {
                     throw new Error(`Can't convert "${rawValue}" to number while parsing ${attr.name}.`);
                 }
                 return v;
             }
             case AttributeValueType.String:
-                return new String(rawValue);
+                return new String(rawValue).toString();
         }
     }
 

diff --git a/tests/helpers/utils/attributes.spec.ts b/tests/helpers/utils/attributes.spec.ts
@@ -0,0 +1,163 @@
+import { AttributeParser, AttributeDefinition, AttributeValueType } from "@templates/helpers/utils/attributes";
+
+describe("Attribute parser", () => {
+    test("should be able to set default values", () => {
+        const schema: AttributeDefinition[] = [
+            {
+                name: "v1",
+                valueType: AttributeValueType.String,
+                defaultValue: "s1"
+            },
+            {
+                name: "v2",
+                valueType: AttributeValueType.String,
+                defaultValue: "s2"
+            },
+            {
+                name: "v3",
+                valueType: AttributeValueType.Number,
+                defaultValue: 3
+            },
+            {
+                name: "v4",
+                valueType: AttributeValueType.Boolean,
+                defaultValue: false
+            }
+        ];
+
+        const attrs = new AttributeParser(schema).parse({
+            v5: "test1",
+            v2: "test2"
+        });
+
+        expect(attrs.v1).toEqual("s1");
+        expect(attrs.v2).toEqual("test2");
+        expect(attrs.v3).toEqual(3);
+        expect(attrs.v4).toEqual(false);
+    });
+
+    test("should be able to parse string values", () => {
+        const schema: AttributeDefinition[] = [
+            {
+                name: "v1",
+                valueType: AttributeValueType.String,
+                defaultValue: "s1"
+            },
+            {
+                name: "v2",
+                valueType: AttributeValueType.String,
+                defaultValue: "s2"
+            },
+            {
+                name: "v3",
+                valueType: AttributeValueType.String,
+                defaultValue: "s3"
+            },
+            {
+                name: "v4",
+                valueType: AttributeValueType.String,
+                defaultValue: "s4"
+            }
+        ];
+
+        const attrs = new AttributeParser(schema).parse({
+            v1: "test1",
+            v2: 123456789,
+            v3: false,
+        });
+
+        expect(attrs.v1).toEqual("test1");
+        expect(attrs.v2).toEqual("123456789");
+        expect(attrs.v3).toEqual("false");
+        expect(attrs.v4).toEqual("s4");
+    });
+
+    test("should be able to parse number values", () => {
+        const schema: AttributeDefinition[] = [
+            {
+                name: "v1",
+                valueType: AttributeValueType.Number,
+                defaultValue: 1
+            },
+            {
+                name: "v2",
+                valueType: AttributeValueType.Number,
+                defaultValue: 2
+            },
+            {
+                name: "v3",
+                valueType: AttributeValueType.Number,
+                defaultValue: 3
+            },
+        ];
+
+        const attrs = new AttributeParser(schema).parse({
+            v1: "123456789",
+            v2: 987654321,
+        });
+
+        expect(attrs.v1).toEqual(123456789);
+        expect(attrs.v2).toEqual(987654321);
+        expect(attrs.v3).toEqual(3);
+    });
+
+    test("should throw error when can't parse number values", () => {
+        const schema: AttributeDefinition[] = [
+            {
+                name: "v1",
+                valueType: AttributeValueType.Number,
+                defaultValue: 1
+            },
+        ];
+
+        const parser = new AttributeParser(schema);
+
+        expect(() => parser.parse({ v1: "abcd" })).toThrow();
+        expect(() => parser.parse({ v1: false })).toThrow();
+        expect(() => parser.parse({ v1: "123" })).not.toThrow();
+        expect(() => parser.parse({ v1: 123 })).not.toThrow();
+    });
+
+    test("should be able to parse boolean values", () => {
+        const schema: AttributeDefinition[] = [
+            {
+                name: "v1",
+                valueType: AttributeValueType.Boolean,
+                defaultValue: true
+            },
+            {
+                name: "v2",
+                valueType: AttributeValueType.Boolean,
+                defaultValue: true
+            },
+            {
+                name: "v3",
+                valueType: AttributeValueType.Boolean,
+                defaultValue: false
+            },
+            {
+                name: "v4",
+                valueType: AttributeValueType.Boolean,
+                defaultValue: false
+            },
+            {
+                name: "v5",
+                valueType: AttributeValueType.Boolean,
+                defaultValue: false
+            },
+        ];
+
+        const attrs = new AttributeParser(schema).parse({
+            v1: "",
+            v2: 0,
+            v3: 5,
+            v4: false,
+        });
+
+        expect(attrs.v1).toEqual(false);
+        expect(attrs.v2).toEqual(false);
+        expect(attrs.v3).toEqual(true);
+        expect(attrs.v4).toEqual(false);
+        expect(attrs.v5).toEqual(false);
+    });
+});