framework/utils/objects.test.ts

import * as objects from "@framework/utils/objects";
import { describe, expect, it } from "vitest";

describe("utils/objects", () => {
    describe("get", () => {
        it("should return the value at the specified path", () => {
            const object = {
                a: {
                    b: {
                        c: "value"
                    }
                }
            };

            expect(objects.get(object, "a.b.c")).toBe("value");
        });

        it("should return undefined if the path does not exist", () => {
            const object = {
                a: {
                    b: {
                        c: "value"
                    }
                }
            };

            expect(objects.get(object, "a.b.d")).toBeUndefined();
        });

        it("should return undefined if the path is invalid", () => {
            const object = {
                a: {
                    b: {
                        c: "value"
                    }
                }
            };

            expect(objects.get(object, "a.b.c.d")).toBeUndefined();
        });

        it("should return undefined if the object is null", () => {
            expect(objects.get(null as unknown as object, "a.b.c")).toBeUndefined();
        });

        it("should return undefined if the object is undefined", () => {
            expect(objects.get(undefined as unknown as object, "a.b.c")).toBeUndefined();
        });

        it("should return undefined if the object is not an object", () => {
            expect(objects.get("string" as unknown as object, "a.b.c")).toBeUndefined();
        });

        it("should throw if the path is not a string or is empty string", () => {
            const object = {
                a: {
                    b: {
                        c: "value"
                    }
                }
            };

            expect(() => objects.get(object, 1 as unknown as string)).toThrowError();
            expect(() => objects.get(object, "" as unknown as string)).toThrowError();
        });

        it("should return undefined if the path is a space", () => {
            const object = {
                a: {
                    b: {
                        c: "value"
                    }
                }
            };

            expect(objects.get(object, " ")).toBeUndefined();
        });

        it("should return undefined if the path is a period", () => {
            const object = {
                a: {
                    b: {
                        c: "value"
                    }
                }
            };

            expect(objects.get(object, ".")).toBeUndefined();
        });
    });
});
1	import * as objects from "@framework/utils/objects";
2	import { describe, expect, it } from "vitest";
3
4	describe("utils/objects", () => {
5	describe("get", () => {
6	it("should return the value at the specified path", () => {
7	const object = {
8	a: {
9	b: {
10	c: "value"
11	}
12	}
13	};
14
15	expect(objects.get(object, "a.b.c")).toBe("value");
16	});
17
18	it("should return undefined if the path does not exist", () => {
19	const object = {
20	a: {
21	b: {
22	c: "value"
23	}
24	}
25	};
26
27	expect(objects.get(object, "a.b.d")).toBeUndefined();
28	});
29
30	it("should return undefined if the path is invalid", () => {
31	const object = {
32	a: {
33	b: {
34	c: "value"
35	}
36	}
37	};
38
39	expect(objects.get(object, "a.b.c.d")).toBeUndefined();
40	});
41
42	it("should return undefined if the object is null", () => {
43	expect(objects.get(null as unknown as object, "a.b.c")).toBeUndefined();
44	});
45
46	it("should return undefined if the object is undefined", () => {
47	expect(objects.get(undefined as unknown as object, "a.b.c")).toBeUndefined();
48	});
49
50	it("should return undefined if the object is not an object", () => {
51	expect(objects.get("string" as unknown as object, "a.b.c")).toBeUndefined();
52	});
53
54	it("should throw if the path is not a string or is empty string", () => {
55	const object = {
56	a: {
57	b: {
58	c: "value"
59	}
60	}
61	};
62
63	expect(() => objects.get(object, 1 as unknown as string)).toThrowError();
64	expect(() => objects.get(object, "" as unknown as string)).toThrowError();
65	});
66
67	it("should return undefined if the path is a space", () => {
68	const object = {
69	a: {
70	b: {
71	c: "value"
72	}
73	}
74	};
75
76	expect(objects.get(object, " ")).toBeUndefined();
77	});
78
79	it("should return undefined if the path is a period", () => {
80	const object = {
81	a: {
82	b: {
83	c: "value"
84	}
85	}
86	};
87
88	expect(objects.get(object, ".")).toBeUndefined();
89	});
90	});
91	});