Merge pull request #230 from dojoengine/recs-work

feat: test cover state & provider

lerna.json

@@ -1,6 +1,6 @@
 {
     "$schema": "node_modules/lerna/schemas/lerna-schema.json",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "packages": ["packages/*", "examples/*"],
     "npmClient": "pnpm"
 }

packages/core/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/core",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Dojo onchain game engine core",
     "author": "Loaf",
     "license": "MIT",

packages/core/test/config/config.test.ts → packages/core/src/_test_/config/config.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
-import { createDojoConfig } from "../../src/config/index";
+import { createDojoConfig } from "../../config/index";
 
 describe("config", () => {
     it("should return an object of type DojoConfigParams", async () => {

packages/core/test/utils/utils.test.ts → packages/core/src/_test_/utils/utils.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "vitest";
-import { getContractByName, parseModelName } from "../../src/utils";
-import manifest from "../../src/utils/manifest.json";
+import { getContractByName, parseModelName } from "../../utils";
+import manifest from "../../utils/manifest.json";
 
 test("get address by contract name", () => {
     expect(getContractByName(manifest, "actions")?.address).toBe(

packages/core/tsconfig.json

@@ -18,7 +18,7 @@
     "include": [
         "src/**/*.ts",
         "bin/generateComponents.cjs",
-        "test/**/*.test.ts"
+        "_test_/**/*.test.ts"
     ],
     "skipLibCheck": true,
     "exclude": ["node_modules", "dist", "**/*.test.ts"]

packages/create-burner/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/create-burner",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Useful hooks and functions to create a Starknet burner wallet",
     "author": "Loaf",
     "license": "MIT",

packages/create-dojo/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/create-dojo",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Scaffold Dojo project from examples",
     "module": "index.ts",
     "main": "./bin/index.js",

packages/react/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/react",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Useful React hooks for Starknet",
     "source": "src/index.ts",
     "main": "dist/index.js",

packages/state/package.json

@@ -1,14 +1,14 @@
 {
     "name": "@dojoengine/state",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "State sync for dojo",
     "author": "Loaf",
     "license": "MIT",
     "main": "dist/index.js",
     "type": "module",
     "scripts": {
         "build": "tsup --dts-resolve",
-        "test": "jest"
+        "test": "vitest"
     },
     "exports": {
         ".": {
@@ -27,6 +27,7 @@
         "@dojoengine/recs": "2.0.13",
         "@dojoengine/torii-client": "workspace:*",
         "@latticexyz/utils": "^2.0.0-next.11",
+        "vitest": "^1.6.0",
         "zustand": "^4.5.2"
     }
 }

packages/state/src/__tests__/recs.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+    getSyncEntities,
+    getEntities,
+    syncEntities,
+    setEntities,
+} from "../recs";
+import { Component, setComponent } from "@dojoengine/recs";
+import { Client } from "@dojoengine/torii-client";
+import { convertValues } from "../utils";
+
+// Mock dependencies
+vi.mock("@dojoengine/recs", () => ({
+    setComponent: vi.fn(),
+    Component: vi.fn(),
+}));
+
+vi.mock("@dojoengine/torii-client", () => ({
+    Client: vi.fn(),
+}));
+
+vi.mock("../utils", () => ({
+    convertValues: vi.fn(),
+}));
+
+describe("RECS functions", () => {
+    let mockClient: any;
+    let mockComponents: any[];
+
+    beforeEach(() => {
+        mockClient = {
+            getAllEntities: vi.fn(),
+            onEntityUpdated: vi.fn(),
+        };
+        mockComponents = [{ schema: {} }, { schema: {} }];
+        vi.clearAllMocks();
+    });
+
+    describe("getSyncEntities", () => {
+        it("should call getEntities and syncEntities", async () => {
+            const entities = [{ id: 1 }, { id: 2 }];
+            // Mock getAllEntities to return an object
+            mockClient.getAllEntities.mockResolvedValue({ 1: {}, 2: {} });
+
+            await getSyncEntities(mockClient, mockComponents, entities);
+
+            expect(mockClient.getAllEntities).toHaveBeenCalled();
+            expect(mockClient.onEntityUpdated).toHaveBeenCalledWith(
+                entities,
+                expect.any(Function)
+            );
+        });
+    });
+
+    describe("syncEntities", () => {
+        it("should set up entity update listener", async () => {
+            const entities = [{ id: 1 }, { id: 2 }];
+
+            await syncEntities(mockClient, mockComponents, entities);
+
+            expect(mockClient.onEntityUpdated).toHaveBeenCalledWith(
+                entities,
+                expect.any(Function)
+            );
+        });
+    });
+
+    describe("setEntities", () => {
+        it("should set components for each entity", async () => {
+            const entities = {
+                1: { comp1: { value: 10 } },
+                2: { comp2: { value: 20 } },
+            };
+            const components = {
+                comp1: { schema: {} },
+                comp2: { schema: {} },
+            };
+
+            (convertValues as any).mockReturnValue({ value: "converted" });
+
+            await setEntities(entities as any, components as any);
+
+            expect(setComponent).toHaveBeenCalledTimes(2);
+            expect(convertValues).toHaveBeenCalledTimes(2);
+        });
+    });
+});

packages/state/src/__tests__/utils.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from "vitest";
+import { convertValues } from "../utils";
+import { Type as RecsType } from "@dojoengine/recs";
+
+describe("convertValues", () => {
+    // ... existing tests ...
+
+    describe("huge numbers", () => {
+        it("should correctly convert huge BigInt values", () => {
+            const schema = { hugeNumber: RecsType.BigInt };
+            const values = {
+                hugeNumber: {
+                    value: "1000000000000000000000000000000000000000000000000000000000000001",
+                },
+            };
+            const result = convertValues(schema, values);
+            expect(result.hugeNumber).toBe(
+                BigInt(
+                    "1000000000000000000000000000000000000000000000000000000000000001"
+                )
+            );
+        });
+
+        it("should correctly convert huge BigInt values", () => {
+            const schema = { hugeNumber: RecsType.BigInt };
+            const values = {
+                hugeNumber: {
+                    value: "7f000000000000000000000000000000000000000000000000000000103fffff",
+                },
+            };
+            const result = convertValues(schema, values);
+            expect(result.hugeNumber).toBe(
+                BigInt(
+                    "0x7f000000000000000000000000000000000000000000000000000000103fffff"
+                )
+            );
+        });
+
+        it("should correctly convert huge Number values", () => {
+            const schema = { hugeNumber: RecsType.Number };
+            const values = { hugeNumber: { value: "1e+308" } }; // Max safe double
+            const result = convertValues(schema, values);
+            expect(result.hugeNumber).toBe(1e308);
+        });
+
+        it("should handle overflow for Number type", () => {
+            const schema = { overflowNumber: RecsType.Number };
+            const values = { overflowNumber: { value: "1e+309" } }; // Beyond max safe double
+            const result = convertValues(schema, values);
+            expect(result.overflowNumber).toBe(Infinity);
+        });
+
+        it("should correctly convert huge numbers in StringArray", () => {
+            const schema = { hugeArray: RecsType.StringArray };
+            const values = {
+                hugeArray: {
+                    value: [
+                        { value: "12345678901234567890" },
+                        { value: "98765432109876543210" },
+                    ],
+                },
+            };
+            const result = convertValues(schema, values);
+            expect(result.hugeArray).toEqual([
+                12345678901234567890n,
+                98765432109876543210n,
+            ]);
+        });
+    });
+
+    describe("additional test cases", () => {
+        it("should correctly convert boolean values", () => {
+            const schema = { isActive: RecsType.Boolean };
+            const values = { isActive: { value: true } };
+            const result = convertValues(schema, values);
+            expect(result.isActive).toBe(true);
+        });
+
+        it("should correctly convert string values", () => {
+            const schema = { name: RecsType.String };
+            const values = { name: { value: "Test Name" } };
+            const result = convertValues(schema, values);
+            expect(result.name).toBe("Test Name");
+        });
+
+        it("should handle null values", () => {
+            const schema = { nullableField: RecsType.String };
+            const values = { nullableField: { value: null } };
+            const result = convertValues(schema, values);
+            expect(result.nullableField).toBeNull();
+        });
+
+        it("should handle undefined values", () => {
+            const schema = { undefinedField: RecsType.String };
+            const values = { undefinedField: { value: undefined } };
+            const result = convertValues(schema, values);
+            expect(result.undefinedField).toBeUndefined();
+        });
+
+        it("should correctly convert nested schema values", () => {
+            const schema = { nested: { innerField: RecsType.Number } };
+            const values = {
+                nested: { value: { innerField: { value: "42" } } },
+            };
+            const result = convertValues(schema, values);
+            expect(result.nested.innerField).toBe(42);
+        });
+    });
+});

packages/state/src/utils/index.ts

@@ -25,7 +25,16 @@ export function convertValues(schema: Schema, values: any) {
                         (item: any) => item.value.option
                     );
                 } else {
-                    acc[key] = value.value.map((a: any) => Number(a.value));
+                    acc[key] = value.value.map((a: any) => {
+                        try {
+                            return BigInt(a.value);
+                        } catch (error) {
+                            console.warn(
+                                `Failed to convert ${a.value} to BigInt. Using string value instead.`
+                            );
+                            return a.value;
+                        }
+                    });
                 }
                 break;
 
@@ -34,7 +43,15 @@ export function convertValues(schema: Schema, values: any) {
                 break;
 
             case RecsType.BigInt:
-                acc[key] = BigInt(value.value.toString());
+                try {
+                    acc[key] = BigInt(value.value);
+                } catch (error) {
+                    console.warn(
+                        `Failed to convert ${value.value} to BigInt. Using string value instead.`
+                    );
+
+                    acc[key] = BigInt(`0x${value.value}`);
+                }
                 break;
 
             case RecsType.Boolean:

packages/torii-client/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/torii-client",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Torii client for the dojo onchain game engine",
     "keywords": [],
     "author": "Dojo",

packages/torii-wasm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/torii-wasm",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Torii wasm bindings for Dojo onchain game engine",
     "author": "",
     "license": "MIT",

packages/utils-wasm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/utils-wasm",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "snoise wasm bindings for Dojo onchain game engine",
     "author": "",
     "license": "MIT",

packages/utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dojoengine/utils",
-    "version": "0.7.8",
+    "version": "0.7.9-alpha.1",
     "description": "Helpful Dojo onchain game engine utils",
     "author": "Loaf",
     "license": "MIT",