@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/solid/primitives.test.ts

@@ -1,1031 +0,0 @@
-import { createEffect, createMemo, createRoot, createSignal } from "solid-js";
-import { describe, expect, it, vi } from "vitest";
-import {
-	SolidDerivation,
-	SolidResource,
-	SolidState,
-} from "../../src/solid/primitives";
-
-describe("solidPrimitives", () => {
-	describe("SolidState", () => {
-		describe("unit", () => {
-			describe("initialization", () => {
-				it("should initialize with direct value", () => {
-					const state = new SolidState(42);
-					expect(state.get()).toBe(42);
-				});
-
-				it("should create instance with initial value", () => {
-					const state = new SolidState("hello");
-					expect(state).toBeInstanceOf(SolidState);
-					expect(state.get()).toBe("hello");
-				});
-
-				it("should handle number values", () => {
-					const state = new SolidState(42);
-					expect(state.get()).toBe(42);
-				});
-
-				it("should handle string values", () => {
-					const state = new SolidState("hello");
-					expect(state.get()).toBe("hello");
-				});
-
-				it("should handle object values", () => {
-					const obj = { a: 1, b: 2 };
-					const state = new SolidState(obj);
-					expect(state.get()).toBe(obj);
-					expect(state.get()).toEqual({ a: 1, b: 2 });
-				});
-
-				it("should handle array values", () => {
-					const arr = [1, 2, 3];
-					const state = new SolidState(arr);
-					expect(state.get()).toBe(arr);
-					expect(state.get()).toEqual([1, 2, 3]);
-				});
-
-				it("should handle null values", () => {
-					const state = new SolidState(null);
-					expect(state.get()).toBeNull();
-				});
-
-				it("should handle undefined values", () => {
-					const state = new SolidState(undefined);
-					expect(state.get()).toBeUndefined();
-				});
-			});
-
-			describe("get", () => {
-				it("should return initial value", () => {
-					const state = new SolidState(5);
-					expect(state.get()).toBe(5);
-				});
-
-				it("should return updated value after set", () => {
-					const state = new SolidState(5);
-					state.set(10);
-					expect(state.get()).toBe(10);
-				});
-
-				it("should be reactive within createRoot", async () => {
-					await createRoot(async (dispose) => {
-						const state = new SolidState(0);
-						const fn = vi.fn();
-
-						createEffect(() => {
-							fn(state.get());
-						});
-
-						await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-						expect(fn).toHaveBeenLastCalledWith(0);
-						expect(state.get()).toBe(0);
-
-						state.set(1);
-						await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(2));
-						expect(fn).toHaveBeenLastCalledWith(1);
-						expect(state.get()).toBe(1);
-
-						state.set(2);
-						await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(3));
-						expect(fn).toHaveBeenLastCalledWith(2);
-						expect(state.get()).toBe(2);
-
-						dispose();
-					});
-				});
-			});
-
-			describe("set", () => {
-				it("should update value with direct value", () => {
-					const state = new SolidState(1);
-					expect(state.get()).toBe(1);
-
-					state.set(2);
-					expect(state.get()).toBe(2);
-				});
-
-				it("should update value with updater function", () => {
-					const state = new SolidState(1);
-					expect(state.get()).toBe(1);
-
-					state.set((prev) => prev + 1);
-					expect(state.get()).toBe(2);
-
-					state.set((prev) => prev * 2);
-					expect(state.get()).toBe(4);
-				});
-
-				it("should handle number values", () => {
-					const state = new SolidState(0);
-					state.set(42);
-					expect(state.get()).toBe(42);
-				});
-
-				it("should handle string values", () => {
-					const state = new SolidState("hello");
-					state.set("world");
-					expect(state.get()).toBe("world");
-				});
-
-				it("should handle object values", () => {
-					const state = new SolidState({ a: 1 });
-					// @ts-expect-error - we want to test the behavior of the state
-					state.set({ a: 2, b: 3 });
-					expect(state.get()).toEqual({ a: 2, b: 3 });
-				});
-
-				it("should handle array values", () => {
-					const state = new SolidState([1, 2]);
-					state.set([3, 4, 5]);
-					expect(state.get()).toEqual([3, 4, 5]);
-				});
-
-				it("should handle null values", () => {
-					const state = new SolidState(1);
-					// @ts-expect-error - we want to test the behavior of the state
-					state.set(null);
-					expect(state.get()).toBeNull();
-				});
-
-				it("should handle undefined values", () => {
-					const state = new SolidState(1);
-					// @ts-expect-error - we want to test the behavior of the state
-					state.set(undefined);
-					expect(state.get()).toBeUndefined();
-				});
-			});
-		});
-	});
-
-	describe("SolidDerivation", () => {
-		describe("unit", () => {
-			describe("initialization", () => {
-				it("should initialize with getter function", () => {
-					const derivation = new SolidDerivation(() => 42);
-					expect(derivation).toBeInstanceOf(SolidDerivation);
-				});
-
-				it("should initialize with direct value", () => {
-					createRoot(() => {
-						const derivation = new SolidDerivation(() => 42);
-						expect(derivation.get()).toBe(42);
-					});
-				});
-
-				it("should compute lazily on first access", () => {
-					createRoot(() => {
-						const computeFn = vi.fn(() => {
-							return 42;
-						});
-						const derivation = new SolidDerivation(computeFn);
-						// createMemo may call immediately, but we verify it works
-						const value = derivation.get();
-						expect(value).toBe(42);
-						expect(computeFn).toHaveBeenCalled();
-					});
-				});
-			});
-
-			describe("get", () => {
-				it("should return computed value", () => {
-					createRoot(() => {
-						const state = new SolidState(5);
-						const derivation = new SolidDerivation(() => state.get() * 2);
-						expect(derivation.get()).toBe(10);
-					});
-				});
-
-				it("should track dependencies reactively", async () => {
-					await createRoot(async (dispose) => {
-						const state = new SolidState(5);
-						const derivation = new SolidDerivation(() => state.get() * 2);
-						expect(derivation.get()).toBe(10);
-
-						state.set(6);
-						await vi.waitFor(() => expect(derivation.get()).toBe(12));
-
-						dispose();
-					});
-				});
-
-				function tick(): Promise<undefined> {
-					return new Promise((resolve) => {
-						queueMicrotask(resolve as VoidFunction);
-					});
-				}
-
-				it("memo", async () => {
-					await createRoot(async () => {
-						const [signal, setSignal] = createSignal(false);
-						const memo = createMemo(() => signal());
-						expect(memo()).eq(false);
-						setSignal(true);
-						await tick();
-						expect(memo()).eq(true);
-					});
-				});
-
-				it("should recompute when dependency changes", () => {
-					return new Promise<void>((resolve) => {
-						createRoot(() => {
-							const state = new SolidState(1);
-							const derivation = new SolidDerivation(() => state.get() * 2);
-
-							expect(derivation.get()).toBe(2);
-
-							state.set(2);
-							queueMicrotask(() => {
-								expect(derivation.get()).toBe(4);
-
-								state.set(3);
-								queueMicrotask(() => {
-									expect(derivation.get()).toBe(6);
-									resolve();
-								});
-							});
-						});
-					});
-				});
-
-				it("should memoize computed value", () => {
-					return new Promise<void>((resolve) => {
-						let computeCount = 0;
-
-						createRoot(() => {
-							const state = new SolidState(5);
-							const derivation = new SolidDerivation(() => {
-								computeCount++;
-								return state.get() * 2;
-							});
-
-							// First access
-							expect(derivation.get()).toBe(10);
-							expect(computeCount).toBe(1);
-
-							// Second access without change
-							expect(derivation.get()).toBe(10);
-							expect(computeCount).toBe(1); // Should not recompute
-
-							// Change dependency
-							state.set(6);
-							queueMicrotask(() => {
-								expect(derivation.get()).toBe(12);
-								expect(computeCount).toBe(2);
-								resolve();
-							});
-						});
-					});
-				});
-
-				it("should handle multiple dependencies", () => {
-					return new Promise<void>((resolve) => {
-						createRoot(() => {
-							const firstName = new SolidState("John");
-							const lastName = new SolidState("Doe");
-							const fullName = new SolidDerivation(
-								() => `${firstName.get()} ${lastName.get()}`,
-							);
-
-							expect(fullName.get()).toBe("John Doe");
-
-							firstName.set("Jane");
-							queueMicrotask(() => {
-								expect(fullName.get()).toBe("Jane Doe");
-
-								lastName.set("Smith");
-								queueMicrotask(() => {
-									expect(fullName.get()).toBe("Jane Smith");
-									resolve();
-								});
-							});
-						});
-					});
-				});
-
-				it("should handle nested derivations", () => {
-					return new Promise<void>((resolve) => {
-						createRoot(() => {
-							const base = new SolidState(2);
-							const doubled = new SolidDerivation(() => base.get() * 2);
-							const quadrupled = new SolidDerivation(() => doubled.get() * 2);
-
-							expect(quadrupled.get()).toBe(8);
-
-							base.set(3);
-							queueMicrotask(() => {
-								expect(quadrupled.get()).toBe(12);
-								resolve();
-							});
-						});
-					});
-				});
-
-				it("should handle number return values", () => {
-					createRoot(() => {
-						const state = new SolidState(5);
-						const derivation = new SolidDerivation(() => state.get() * 2);
-						expect(derivation.get()).toBe(10);
-					});
-				});
-
-				it("should handle string return values", () => {
-					createRoot(() => {
-						const state = new SolidState("hello");
-						const derivation = new SolidDerivation(() =>
-							state.get().toUpperCase(),
-						);
-						expect(derivation.get()).toBe("HELLO");
-					});
-				});
-
-				it("should handle object return values", () => {
-					createRoot(() => {
-						const state = new SolidState({ a: 1 });
-						const derivation = new SolidDerivation(() => ({
-							...state.get(),
-							b: 2,
-						}));
-						expect(derivation.get()).toEqual({ a: 1, b: 2 });
-					});
-				});
-
-				it("should handle array return values", () => {
-					createRoot(() => {
-						const state = new SolidState([1, 2]);
-						const derivation = new SolidDerivation(() => [...state.get(), 3]);
-						expect(derivation.get()).toEqual([1, 2, 3]);
-					});
-				});
-
-				it("should handle null return values", () => {
-					createRoot(() => {
-						const state = new SolidState(true);
-						const derivation = new SolidDerivation(() =>
-							state.get() ? null : "not null",
-						);
-						expect(derivation.get()).toBeNull();
-					});
-				});
-
-				it("should handle undefined return values", () => {
-					createRoot(() => {
-						const state = new SolidState(true);
-						const derivation = new SolidDerivation(() =>
-							state.get() ? undefined : "defined",
-						);
-						expect(derivation.get()).toBeUndefined();
-					});
-				});
-			});
-		});
-	});
-
-	describe("SolidResource", () => {
-		describe("unit", () => {
-			describe("initialization", () => {
-				it("should initialize with fetcher function", () => {
-					createRoot(() => {
-						const fetcher = vi.fn(async () => 42);
-						const resource = new SolidResource(fetcher);
-						expect(resource).toBeInstanceOf(SolidResource);
-					});
-				});
-
-				it("should start in unresolved state", () => {
-					createRoot(() => {
-						const fetcher = vi.fn(async () => 42);
-						const resource = new SolidResource(fetcher);
-						expect(resource.state()).toBe("pending");
-					});
-				});
-			});
-
-			describe("get", () => {
-				it("should return undefined initially", () => {
-					const fetcher = vi.fn(async () => 42);
-					const resource = new SolidResource(fetcher);
-
-					createRoot(() => {
-						expect(resource.get()).toBeUndefined();
-					});
-				});
-
-				it("should return value after fetch completes", async () => {
-					const fetcher = vi.fn(async () => 42);
-					let value: number | undefined;
-
-					await createRoot(async (dispose) => {
-						const resource = new SolidResource(fetcher);
-
-						// Wait for resource to load
-						await new Promise((resolve) => {
-							createEffect(() => {
-								if (resource.state() === "ready") {
-									value = resource.get();
-									resolve(undefined);
-								}
-							});
-						});
-
-						dispose();
-					});
-
-					expect(value).toBe(42);
-				});
-
-				it("should be reactive within createRoot", async () => {
-					let effectCount = 0;
-
-					await createRoot(async (dispose) => {
-						let counter = 0;
-						const fetcher = vi.fn(async () => {
-							counter++;
-							return counter;
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						createEffect(() => {
-							effectCount++;
-							resource.get();
-						});
-
-						// Wait for initial load
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(effectCount).toBeGreaterThan(0);
-
-						// Trigger refetch
-						resource.refetch();
-
-						// Wait for refetch
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						dispose();
-					});
-
-					expect(effectCount).toBeGreaterThan(1);
-				});
-			});
-
-			describe("state", () => {
-				it("should return 'unresolved' initially", () => {
-					const fetcher = vi.fn(async () => 42);
-					const resource = new SolidResource(fetcher);
-
-					createRoot(() => {
-						expect(resource.state()).toBe("pending");
-					});
-				});
-
-				it("should return 'pending' during fetch", async () => {
-					let stateDuringFetch: string | undefined;
-
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => {
-							await new Promise((resolve) => setTimeout(resolve, 50));
-							return 42;
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Access get() to trigger fetch
-						resource.get();
-
-						// Check state immediately
-						stateDuringFetch = resource.state();
-
-						// Wait for completion
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						dispose();
-					});
-
-					expect(stateDuringFetch).toBe("pending");
-				});
-
-				it("should return 'ready' after successful fetch", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => 42);
-						const resource = new SolidResource(fetcher);
-
-						// Access get() to trigger fetch
-						resource.get();
-
-						// Wait for completion
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.state()).toBe("ready");
-						dispose();
-					});
-				});
-
-				it("should return 'errored' after failed fetch", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => {
-							throw new Error("Fetch failed");
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Access get() to trigger fetch
-						resource.get();
-
-						// Wait for error
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "errored") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.state()).toBe("errored");
-						dispose();
-					});
-				});
-
-				it("should return 'refreshing' during refetch", async () => {
-					let stateDuringRefetch: string | undefined;
-
-					await createRoot(async (dispose) => {
-						let callCount = 0;
-						const fetcher = vi.fn(async () => {
-							callCount++;
-							await new Promise((resolve) => setTimeout(resolve, 50));
-							return callCount;
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						// Trigger refetch
-						resource.refetch();
-
-						// Check state immediately
-						stateDuringRefetch = resource.state();
-
-						// Wait for completion
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						dispose();
-					});
-
-					expect(stateDuringRefetch).toBe("refreshing");
-				});
-			});
-
-			describe("latest", () => {
-				it("should return undefined initially", () => {
-					const fetcher = vi.fn(async () => 42);
-					const resource = new SolidResource(fetcher);
-
-					createRoot(() => {
-						expect(resource.latest()).toBeUndefined();
-					});
-				});
-
-				it("should return last successful value", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => 42);
-						const resource = new SolidResource(fetcher);
-
-						// Access get() to trigger fetch
-						resource.get();
-
-						// Wait for completion
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.latest()).toBe(42);
-						dispose();
-					});
-				});
-
-				it("should return previous value during refetch", async () => {
-					await createRoot(async (dispose) => {
-						let callCount = 0;
-						const fetcher = vi.fn(async () => {
-							callCount++;
-							await new Promise((resolve) => setTimeout(resolve, 50));
-							return callCount;
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.latest()).toBe(1);
-
-						// Trigger refetch
-						resource.refetch();
-
-						// Latest should still be previous value during refetch
-						expect(resource.latest()).toBe(1);
-
-						// Wait for refetch completion
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.latest()).toBe(2);
-						dispose();
-					});
-				});
-
-				it("should return previous value even after error", async () => {
-					await createRoot(async (dispose) => {
-						let shouldFail = false;
-						const fetcher = vi.fn(async () => {
-							if (shouldFail) {
-								throw new Error("Fetch failed");
-							}
-							return 42;
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Initial successful fetch
-						await vi.waitFor(() => expect(resource.latest()).toBe(42));
-
-						// Trigger failed fetch
-						shouldFail = true;
-						resource.refetch();
-						await vi.waitFor(() => expect(resource.state()).toBe("errored"));
-
-						dispose();
-					});
-				});
-			});
-
-			describe("refetch", () => {
-				it("should trigger new fetch", async () => {
-					let callCount = 0;
-					const fetcher = vi.fn(async () => {
-						callCount++;
-						return callCount;
-					});
-
-					await createRoot(async (dispose) => {
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(callCount).toBe(1);
-						expect(resource.get()).toBe(1);
-
-						// Refetch
-						resource.refetch();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(callCount).toBe(2);
-						expect(resource.get()).toBe(2);
-						dispose();
-					});
-				});
-
-				it("should update value after refetch", async () => {
-					let counter = 0;
-					const fetcher = vi.fn(async () => {
-						counter++;
-						return counter;
-					});
-
-					await createRoot(async (dispose) => {
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.get()).toBe(1);
-
-						// Refetch
-						resource.refetch();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.get()).toBe(2);
-						dispose();
-					});
-				});
-
-				it("should set state to 'refreshing' during refetch", async () => {
-					let stateDuringRefetch: string | undefined;
-
-					await createRoot(async (dispose) => {
-						let callCount = 0;
-						const fetcher = vi.fn(async () => {
-							callCount++;
-							await new Promise((resolve) => setTimeout(resolve, 50));
-							return callCount;
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						// Trigger refetch
-						resource.refetch();
-
-						// Check state immediately
-						stateDuringRefetch = resource.state();
-
-						// Wait for completion
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						dispose();
-					});
-
-					expect(stateDuringRefetch).toBe("refreshing");
-				});
-			});
-
-			describe("set", () => {
-				it("should update value with direct value", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => 42);
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.get()).toBe(42);
-
-						// Mutate value
-						resource.set(100);
-						expect(resource.get()).toBe(100);
-						dispose();
-					});
-				});
-
-				it("should update value with updater function", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => 42);
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.get()).toBe(42);
-
-						// Mutate with updater
-						resource.set((prev) => (prev ?? 0) * 2);
-						expect(resource.get()).toBe(84);
-						dispose();
-					});
-				});
-
-				it("should mutate resource value", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => ({ count: 1 }));
-						const resource = new SolidResource(fetcher);
-
-						// Initial fetch
-						resource.get();
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "ready") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						const initialValue = resource.get();
-						expect(initialValue).toEqual({ count: 1 });
-
-						// Mutate
-						resource.set({ count: 2 });
-						expect(resource.get()).toEqual({ count: 2 });
-						dispose();
-					});
-				});
-			});
-
-			describe("error handling", () => {
-				it("should handle fetch errors", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => {
-							throw new Error("Fetch failed");
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Access get() to trigger fetch
-						resource.get();
-
-						// Wait for error
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "errored") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.state()).toBe("errored");
-						dispose();
-					});
-				});
-
-				it("should set state to 'errored' on fetch failure", async () => {
-					await createRoot(async (dispose) => {
-						const fetcher = vi.fn(async () => {
-							throw new Error("Network error");
-						});
-
-						const resource = new SolidResource(fetcher);
-
-						// Access get() to trigger fetch
-						resource.get();
-
-						// Wait for error
-						await new Promise((resolve) => {
-							const check = () => {
-								if (resource.state() === "errored") {
-									resolve(undefined);
-								} else {
-									setTimeout(check, 10);
-								}
-							};
-							check();
-						});
-
-						expect(resource.state()).toBe("errored");
-						dispose();
-					});
-				});
-			});
-		});
-	});
-});