@ersbeth/picoflow 1.0.0 → 1.1.0

package/test/solid/primitives.test.ts

@@ -0,0 +1,1031 @@
+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();
+					});
+				});
+			});
+		});
+	});
+});