fork refine

packages/appwrite/test/utils/generateFilter.spec.ts

@@ -0,0 +1,54 @@
+import { Query } from "appwrite";
+import { generateFilter } from "../../src/utils";
+import { CrudFilter } from "@refinedev/core";
+
+describe("generateFilter", () => {
+    it("should generate filter based on the specified operator", () => {
+        const testCases: { filter: CrudFilter; expected: any }[] = [
+            {
+                filter: { operator: "eq", field: "name", value: "John" },
+                expected: Query.equal("name", "John"),
+            },
+            {
+                filter: { operator: "ne", field: "name", value: "John" },
+                expected: Query.notEqual("name", "John"),
+            },
+            {
+                filter: { operator: "gt", field: "age", value: 25 },
+                expected: Query.greaterThan("age", 25),
+            },
+            {
+                filter: { operator: "gte", field: "age", value: 25 },
+                expected: Query.greaterThanEqual("age", 25),
+            },
+            {
+                filter: { operator: "lt", field: "age", value: 25 },
+                expected: Query.lessThan("age", 25),
+            },
+            {
+                filter: { operator: "lte", field: "age", value: 25 },
+                expected: Query.lessThanEqual("age", 25),
+            },
+            {
+                filter: { operator: "contains", field: "name", value: "John" },
+                expected: Query.search("name", "%John%"),
+            },
+        ];
+
+        testCases.forEach(({ filter, expected }) => {
+            const result = generateFilter(filter);
+            expect(result).toEqual(expected);
+        });
+    });
+
+    it("should throw an error for unsupported operator", () => {
+        const filter = {
+            operator: "unsupported",
+            field: "name",
+            value: "John",
+        };
+        expect(() => generateFilter(filter as any)).toThrowError(
+            `Operator ${filter.operator} is not supported`,
+        );
+    });
+});

packages/appwrite/test/utils/gerRefineEvent.spec.ts

@@ -0,0 +1,25 @@
+import { getRefineEvent } from "../../src/utils";
+
+describe("getRefineEvent", () => {
+    it("should return 'created' when the event includes '.create'", () => {
+        const event = "user.create";
+        const expected = "created";
+        expect(getRefineEvent(event)).toBe(expected);
+    });
+
+    it("should return 'undefined' when the event includes '.update'", () => {
+        const event = "user.update";
+        expect(getRefineEvent(event)).toBeUndefined();
+    });
+
+    it("should return 'deleted' when the event includes '.delete'", () => {
+        const event = "user.delete";
+        const expected = "deleted";
+        expect(getRefineEvent(event)).toBe(expected);
+    });
+
+    it("should return 'undefined' when the event does not match any pattern", () => {
+        const event = "user.unknown";
+        expect(getRefineEvent(event)).toBeUndefined();
+    });
+});

packages/appwrite/test/utils/getAppwriteFilters.spec.ts

@@ -0,0 +1,66 @@
+import { CrudFilter } from "@refinedev/core";
+import { generateFilter, getAppwriteFilters } from "../../src/utils";
+
+jest.mock("../../src/utils/generateFilter", () => ({
+    generateFilter: jest.fn(),
+}));
+
+describe("getAppwriteFilters", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should generate Appwrite filters based on the input filters", () => {
+        const filters: CrudFilter[] = [
+            { operator: "eq", field: "name", value: "John" },
+            { operator: "lt", field: "age", value: 30 },
+        ];
+
+        getAppwriteFilters(filters);
+
+        expect(generateFilter).toHaveBeenCalledTimes(2);
+        expect(generateFilter).toHaveBeenNthCalledWith(1, {
+            operator: "eq",
+            field: "name",
+            value: "John",
+        });
+        expect(generateFilter).toHaveBeenNthCalledWith(2, {
+            operator: "lt",
+            field: "age",
+            value: 30,
+        });
+    });
+
+    it('should not generate Appwrite filters for "or" and "and" operators', () => {
+        const filters = [
+            { operator: "or", filters: [] },
+            { operator: "and", filters: [] },
+        ];
+
+        getAppwriteFilters(filters as any);
+
+        expect(generateFilter).toHaveBeenCalledTimes(0);
+    });
+
+    it('should replace "id" field with "$id"', () => {
+        const filters: CrudFilter[] = [
+            { operator: "eq", field: "id", value: "123" },
+        ];
+
+        getAppwriteFilters(filters);
+
+        expect(generateFilter).toHaveBeenCalledTimes(1);
+        expect(generateFilter).toHaveBeenCalledWith({
+            operator: "eq",
+            field: "$id",
+            value: "123",
+        });
+    });
+
+    it("should return an empty array when no filters are provided", () => {
+        const result = getAppwriteFilters(undefined);
+
+        expect(result).toEqual([]);
+        expect(generateFilter).toHaveBeenCalledTimes(0);
+    });
+});

packages/appwrite/test/utils/getAppwritePagination.spec.ts

@@ -0,0 +1,38 @@
+import { getAppwritePagination } from "../../src/utils";
+
+import { Query } from "appwrite";
+
+describe("getAppwritePagination", () => {
+    it("should generate Appwrite pagination parameters based on the current page and page size", () => {
+        const current = 2;
+        const pageSize = 10;
+
+        const result = getAppwritePagination(current, pageSize);
+
+        expect(result).toEqual([
+            Query.offset((current - 1) * pageSize),
+            Query.limit(pageSize),
+        ]);
+    });
+
+    it("should generate correct Appwrite pagination parameters for the first page", () => {
+        const current = 1;
+        const pageSize = 10;
+
+        const result = getAppwritePagination(current, pageSize);
+
+        expect(result).toEqual([Query.offset(0), Query.limit(pageSize)]);
+    });
+
+    it("should generate correct Appwrite pagination parameters for a custom page size", () => {
+        const current = 3;
+        const pageSize = 5;
+
+        const result = getAppwritePagination(current, pageSize);
+
+        expect(result).toEqual([
+            Query.offset((current - 1) * pageSize),
+            Query.limit(pageSize),
+        ]);
+    });
+});

packages/appwrite/test/utils/getAppwriteSorting.ts

@@ -0,0 +1,33 @@
+import { CrudSorting } from "@refinedev/core";
+import { getAppwriteSorting } from "../../src/utils";
+import { Query } from "appwrite";
+
+describe("getAppwriteSorting", () => {
+    it("should generate Appwrite sorting parameters based on the provided sorters", () => {
+        const sorters: CrudSorting = [
+            { field: "name", order: "asc" },
+            { field: "age", order: "desc" },
+        ];
+
+        const result = getAppwriteSorting(sorters);
+
+        expect(result).toEqual([
+            Query.orderAsc("name"),
+            Query.orderDesc("age"),
+        ]);
+    });
+
+    it('should generate correct Appwrite sorting parameters for the "id" field', () => {
+        const sorters: CrudSorting = [{ field: "id", order: "asc" }];
+
+        const result = getAppwriteSorting(sorters);
+
+        expect(result).toEqual([Query.orderAsc("$id")]);
+    });
+
+    it("should return an empty array when no sorters are provided", () => {
+        const result = getAppwriteSorting(undefined);
+
+        expect(result).toEqual([]);
+    });
+});