additional unit tests

Author: matas-bitbybit-dev

packages/dev/threejs/lib/api/bitbybit-base.test.ts

@@ -0,0 +1,333 @@
+import * as THREEJS from "three";
+import { BitByBitBase } from "./bitbybit-base";
+
+describe("BitByBitBase unit tests", () => {
+    let bitByBit: BitByBitBase;
+
+    beforeEach(() => {
+        bitByBit = new BitByBitBase();
+    });
+
+    describe("Constructor initialization", () => {
+        it("should create a BitByBitBase instance", () => {
+            expect(bitByBit).toBeDefined();
+            expect(bitByBit).toBeInstanceOf(BitByBitBase);
+        });
+
+        it("should initialize context", () => {
+            expect(bitByBit.context).toBeDefined();
+        });
+
+        it("should initialize worker managers", () => {
+            expect(bitByBit.jscadWorkerManager).toBeDefined();
+            expect(bitByBit.manifoldWorkerManager).toBeDefined();
+            expect(bitByBit.occtWorkerManager).toBeDefined();
+        });
+
+        it("should initialize math service", () => {
+            expect(bitByBit.math).toBeDefined();
+        });
+
+        it("should initialize logic service", () => {
+            expect(bitByBit.logic).toBeDefined();
+        });
+
+        it("should initialize lists service", () => {
+            expect(bitByBit.lists).toBeDefined();
+        });
+
+        it("should initialize json service", () => {
+            expect(bitByBit.json).toBeDefined();
+        });
+
+        it("should initialize vector service", () => {
+            expect(bitByBit.vector).toBeDefined();
+        });
+
+        it("should initialize three service", () => {
+            expect(bitByBit.three).toBeDefined();
+        });
+
+        it("should initialize point service", () => {
+            expect(bitByBit.point).toBeDefined();
+        });
+
+        it("should initialize line service", () => {
+            expect(bitByBit.line).toBeDefined();
+        });
+
+        it("should initialize transforms service", () => {
+            expect(bitByBit.transforms).toBeDefined();
+        });
+
+        it("should initialize polyline service", () => {
+            expect(bitByBit.polyline).toBeDefined();
+        });
+
+        it("should initialize draw service", () => {
+            expect(bitByBit.draw).toBeDefined();
+        });
+
+        it("should initialize verb service", () => {
+            expect(bitByBit.verb).toBeDefined();
+        });
+
+        it("should initialize jscad service", () => {
+            expect(bitByBit.jscad).toBeDefined();
+        });
+
+        it("should initialize manifold service", () => {
+            expect(bitByBit.manifold).toBeDefined();
+        });
+
+        it("should initialize text service", () => {
+            expect(bitByBit.text).toBeDefined();
+        });
+
+        it("should initialize dates service", () => {
+            expect(bitByBit.dates).toBeDefined();
+        });
+
+        it("should initialize tag service", () => {
+            expect(bitByBit.tag).toBeDefined();
+        });
+
+        it("should initialize time service", () => {
+            expect(bitByBit.time).toBeDefined();
+        });
+
+        it("should initialize occt service", () => {
+            expect(bitByBit.occt).toBeDefined();
+        });
+
+        it("should initialize mesh service", () => {
+            expect(bitByBit.mesh).toBeDefined();
+        });
+
+        it("should initialize asset service", () => {
+            expect(bitByBit.asset).toBeDefined();
+        });
+
+        it("should initialize color service", () => {
+            expect(bitByBit.color).toBeDefined();
+        });
+    });
+
+    describe("init method", () => {
+        it("should initialize with scene only", () => {
+            const scene = new THREEJS.Scene();
+            bitByBit.init(scene);
+            expect(bitByBit.context.scene).toBe(scene);
+        });
+
+        it("should set verb context", () => {
+            const scene = new THREEJS.Scene();
+            bitByBit.init(scene);
+            expect(bitByBit.context.verb).toBeDefined();
+            expect(bitByBit.context.verb.geom).toBeDefined();
+            expect(bitByBit.context.verb.core).toBeDefined();
+        });
+
+        it("should set jsonpath context", () => {
+            const scene = new THREEJS.Scene();
+            bitByBit.init(scene);
+            expect(bitByBit.context.jsonpath).toBeDefined();
+        });
+
+        it("should initialize with scene and occt worker", () => {
+            const scene = new THREEJS.Scene();
+            const mockOcctWorker = {
+                postMessage: jest.fn(),
+                addEventListener: jest.fn(),
+                removeEventListener: jest.fn(),
+                terminate: jest.fn(),
+                onmessage: null,
+                onmessageerror: null,
+                onerror: null,
+                dispatchEvent: jest.fn(),
+            } as unknown as Worker;
+            
+            bitByBit.init(scene, mockOcctWorker);
+            expect(bitByBit.context.scene).toBe(scene);
+        });
+
+        it("should initialize with scene and jscad worker", () => {
+            const scene = new THREEJS.Scene();
+            const mockJscadWorker = {
+                postMessage: jest.fn(),
+                addEventListener: jest.fn(),
+                removeEventListener: jest.fn(),
+                terminate: jest.fn(),
+                onmessage: null,
+                onmessageerror: null,
+                onerror: null,
+                dispatchEvent: jest.fn(),
+            } as unknown as Worker;
+            
+            bitByBit.init(scene, undefined, mockJscadWorker);
+            expect(bitByBit.context.scene).toBe(scene);
+        });
+
+        it("should initialize with scene and manifold worker", () => {
+            const scene = new THREEJS.Scene();
+            const mockManifoldWorker = {
+                postMessage: jest.fn(),
+                addEventListener: jest.fn(),
+                removeEventListener: jest.fn(),
+                terminate: jest.fn(),
+                onmessage: null,
+                onmessageerror: null,
+                onerror: null,
+                dispatchEvent: jest.fn(),
+            } as unknown as Worker;
+            
+            bitByBit.init(scene, undefined, undefined, mockManifoldWorker);
+            expect(bitByBit.context.scene).toBe(scene);
+        });
+
+        it("should initialize with all workers", () => {
+            const scene = new THREEJS.Scene();
+            const createMockWorker = () => ({
+                postMessage: jest.fn(),
+                addEventListener: jest.fn(),
+                removeEventListener: jest.fn(),
+                terminate: jest.fn(),
+                onmessage: null,
+                onmessageerror: null,
+                onerror: null,
+                dispatchEvent: jest.fn(),
+            } as unknown as Worker);
+            
+            const mockOcctWorker = createMockWorker();
+            const mockJscadWorker = createMockWorker();
+            const mockManifoldWorker = createMockWorker();
+            
+            bitByBit.init(scene, mockOcctWorker, mockJscadWorker, mockManifoldWorker);
+            expect(bitByBit.context.scene).toBe(scene);
+        });
+
+        it("should handle undefined workers gracefully", () => {
+            const scene = new THREEJS.Scene();
+            expect(() => bitByBit.init(scene, undefined, undefined, undefined)).not.toThrow();
+            expect(bitByBit.context.scene).toBe(scene);
+        });
+    });
+
+    describe("Service integration", () => {
+        it("should have functional math operations", () => {
+            // Test basic number creation instead of twoNrOperation which requires proper enum
+            const result = bitByBit.math.number({ number: 42 });
+            expect(result).toBe(42);
+        });
+
+        it("should have functional math rounding", () => {
+            const result = bitByBit.math.roundToDecimals({ number: 3.14159, decimalPlaces: 2 });
+            expect(result).toBeCloseTo(3.14, 2);
+        });
+
+        it("should have functional vector operations", () => {
+            const result = bitByBit.vector.add({ first: [1, 2, 3], second: [4, 5, 6] });
+            expect(result).toEqual([5, 7, 9]);
+        });
+
+        it("should have functional point operations", () => {
+            const result = bitByBit.point.distance({ startPoint: [0, 0, 0], endPoint: [3, 4, 0] });
+            expect(result).toBeCloseTo(5, 5);
+        });
+
+        it("should have functional line creation", () => {
+            const result = bitByBit.line.create({ start: [0, 0, 0], end: [1, 1, 1] });
+            expect(result).toEqual({ start: [0, 0, 0], end: [1, 1, 1] });
+        });
+
+        it("should have functional polyline creation", () => {
+            const result = bitByBit.polyline.create({ points: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] });
+            expect(result.points).toEqual([[0, 0, 0], [1, 0, 0], [1, 1, 0]]);
+            expect(result.isClosed).toBe(false);
+        });
+
+        it("should have functional list operations", () => {
+            const result = bitByBit.lists.getItem({ list: [10, 20, 30], index: 1 });
+            expect(result).toBe(20);
+        });
+
+        it("should have functional transform operations", () => {
+            const result = bitByBit.transforms.translationXYZ({ translation: [1, 2, 3] });
+            expect(result).toBeDefined();
+            expect(Array.isArray(result)).toBe(true);
+        });
+
+        it("should have functional color operations", () => {
+            const result = bitByBit.color.hexToRgb({ color: "#ff0000" });
+            expect(result).toEqual({ r: 255, g: 0, b: 0 });
+        });
+
+        it("should have functional mesh operations", () => {
+            const plane = bitByBit.mesh.calculateTrianglePlane({ 
+                triangle: [[0, 0, 0], [1, 0, 0], [0, 1, 0]] 
+            });
+            expect(plane).toBeDefined();
+            expect(plane.normal).toBeDefined();
+        });
+
+        it("should have functional logic operations", () => {
+            const result = bitByBit.logic.firstDefinedValueGate({ value1: undefined, value2: 5 });
+            expect(result).toBe(5);
+        });
+
+        it("should have functional boolean operations", () => {
+            const result = bitByBit.logic.boolean({ boolean: true });
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("Multiple instances", () => {
+        it("should create independent instances", () => {
+            const instance1 = new BitByBitBase();
+            const instance2 = new BitByBitBase();
+            
+            expect(instance1).not.toBe(instance2);
+            expect(instance1.context).not.toBe(instance2.context);
+        });
+
+        it("should have independent scenes after init", () => {
+            const instance1 = new BitByBitBase();
+            const instance2 = new BitByBitBase();
+            
+            const scene1 = new THREEJS.Scene();
+            const scene2 = new THREEJS.Scene();
+            scene1.name = "scene1";
+            scene2.name = "scene2";
+            
+            instance1.init(scene1);
+            instance2.init(scene2);
+            
+            expect(instance1.context.scene).toBe(scene1);
+            expect(instance2.context.scene).toBe(scene2);
+            expect(instance1.context.scene).not.toBe(instance2.context.scene);
+        });
+    });
+
+    describe("Scene manipulation after init", () => {
+        it("should allow adding objects to the scene via draw", () => {
+            const scene = new THREEJS.Scene();
+            bitByBit.init(scene);
+            
+            // Draw a point
+            const result = bitByBit.draw.drawAny({ entity: [1, 2, 3] });
+            expect(result).toBeDefined();
+            expect(scene.children.length).toBeGreaterThan(0);
+        });
+
+        it("should allow multiple draws to the same scene", () => {
+            const scene = new THREEJS.Scene();
+            bitByBit.init(scene);
+            
+            bitByBit.draw.drawAny({ entity: [1, 2, 3] });
+            bitByBit.draw.drawAny({ entity: [4, 5, 6] });
+            bitByBit.draw.drawAny({ entity: [[0, 0, 0], [1, 1, 1]] }); // line
+            
+            expect(scene.children.length).toBeGreaterThanOrEqual(3);
+        });
+    });
+});