@aaronshaf/plane 0.1.2 → 0.1.5

package/tests/schemas.test.ts

@@ -1,203 +1,241 @@
-import { describe, expect, it } from "bun:test"
-import { Effect, Schema } from "effect"
+import { describe, expect, it } from "bun:test";
+import { Effect, Schema } from "effect";
 import {
-  StateSchema,
-  IssueSchema,
-  IssuesResponseSchema,
-  StatesResponseSchema,
-  ProjectSchema,
-  ProjectsResponseSchema,
-  LabelSchema,
-  LabelsResponseSchema,
-  MemberSchema,
-  MembersResponseSchema,
-  CycleSchema,
-  CyclesResponseSchema,
-} from "@/config"
-
-async function decode<A, I>(schema: Schema.Schema<A, I>, data: unknown): Promise<A> {
-  return Effect.runPromise(
-    Schema.decodeUnknown(schema)(data).pipe(Effect.mapError((e) => new Error(String(e)))),
-  )
+	StateSchema,
+	IssueSchema,
+	IssuesResponseSchema,
+	StatesResponseSchema,
+	ProjectSchema,
+	ProjectsResponseSchema,
+	LabelSchema,
+	LabelsResponseSchema,
+	MemberSchema,
+	MembersResponseSchema,
+	CycleSchema,
+	CyclesResponseSchema,
+} from "@/config";
+
+async function decode<A, I>(
+	schema: Schema.Schema<A, I>,
+	data: unknown,
+): Promise<A> {
+	return Effect.runPromise(
+		Schema.decodeUnknown(schema)(data).pipe(
+			Effect.mapError((e) => new Error(String(e))),
+		),
+	);
 }
 
 describe("StateSchema", () => {
-  it("decodes a valid state", async () => {
-    const state = await decode(StateSchema, { id: "s1", name: "In Progress", group: "started" })
-    expect(state.id).toBe("s1")
-    expect(state.group).toBe("started")
-  })
-
-  it("accepts optional color", async () => {
-    const state = await decode(StateSchema, {
-      id: "s1",
-      name: "Done",
-      group: "completed",
-      color: "#00ff00",
-    })
-    expect(state.color).toBe("#00ff00")
-  })
-
-  it("rejects missing required fields", async () => {
-    await expect(decode(StateSchema, { id: "s1" })).rejects.toThrow()
-  })
-})
+	it("decodes a valid state", async () => {
+		const state = await decode(StateSchema, {
+			id: "s1",
+			name: "In Progress",
+			group: "started",
+		});
+		expect(state.id).toBe("s1");
+		expect(state.group).toBe("started");
+	});
+
+	it("accepts optional color", async () => {
+		const state = await decode(StateSchema, {
+			id: "s1",
+			name: "Done",
+			group: "completed",
+			color: "#00ff00",
+		});
+		expect(state.color).toBe("#00ff00");
+	});
+
+	it("rejects missing required fields", async () => {
+		await expect(decode(StateSchema, { id: "s1" })).rejects.toThrow();
+	});
+});
 
 describe("IssueSchema", () => {
-  const base = {
-    id: "i1",
-    sequence_id: 42,
-    name: "Fix bug",
-    priority: "high",
-    state: "uuid-state",
-  }
-
-  it("decodes with string state", async () => {
-    const issue = await decode(IssueSchema, base)
-    expect(issue.sequence_id).toBe(42)
-    expect(issue.state).toBe("uuid-state")
-  })
-
-  it("decodes with object state", async () => {
-    const issue = await decode(IssueSchema, {
-      ...base,
-      state: { id: "s1", name: "In Progress", group: "started" },
-    })
-    expect(typeof issue.state).toBe("object")
-  })
-
-  it("accepts null description_html", async () => {
-    const issue = await decode(IssueSchema, { ...base, description_html: null })
-    expect(issue.description_html).toBeNull()
-  })
-
-  it("rejects missing name", async () => {
-    await expect(decode(IssueSchema, { ...base, name: undefined })).rejects.toThrow()
-  })
-})
+	const base = {
+		id: "i1",
+		sequence_id: 42,
+		name: "Fix bug",
+		priority: "high",
+		state: "uuid-state",
+	};
+
+	it("decodes with string state", async () => {
+		const issue = await decode(IssueSchema, base);
+		expect(issue.sequence_id).toBe(42);
+		expect(issue.state).toBe("uuid-state");
+	});
+
+	it("decodes with object state", async () => {
+		const issue = await decode(IssueSchema, {
+			...base,
+			state: { id: "s1", name: "In Progress", group: "started" },
+		});
+		expect(typeof issue.state).toBe("object");
+	});
+
+	it("accepts null description_html", async () => {
+		const issue = await decode(IssueSchema, {
+			...base,
+			description_html: null,
+		});
+		expect(issue.description_html).toBeNull();
+	});
+
+	it("rejects missing name", async () => {
+		await expect(
+			decode(IssueSchema, { ...base, name: undefined }),
+		).rejects.toThrow();
+	});
+});
 
 describe("IssuesResponseSchema", () => {
-  it("decodes results array", async () => {
-    const data = {
-      results: [
-        { id: "i1", sequence_id: 1, name: "Issue 1", priority: "low", state: "s1" },
-        { id: "i2", sequence_id: 2, name: "Issue 2", priority: "high", state: "s2" },
-      ],
-    }
-    const resp = await decode(IssuesResponseSchema, data)
-    expect(resp.results).toHaveLength(2)
-  })
-
-  it("decodes empty results", async () => {
-    const resp = await decode(IssuesResponseSchema, { results: [] })
-    expect(resp.results).toHaveLength(0)
-  })
-})
+	it("decodes results array", async () => {
+		const data = {
+			results: [
+				{
+					id: "i1",
+					sequence_id: 1,
+					name: "Issue 1",
+					priority: "low",
+					state: "s1",
+				},
+				{
+					id: "i2",
+					sequence_id: 2,
+					name: "Issue 2",
+					priority: "high",
+					state: "s2",
+				},
+			],
+		};
+		const resp = await decode(IssuesResponseSchema, data);
+		expect(resp.results).toHaveLength(2);
+	});
+
+	it("decodes empty results", async () => {
+		const resp = await decode(IssuesResponseSchema, { results: [] });
+		expect(resp.results).toHaveLength(0);
+	});
+});
 
 describe("StatesResponseSchema", () => {
-  it("decodes results", async () => {
-    const resp = await decode(StatesResponseSchema, {
-      results: [{ id: "s1", name: "Backlog", group: "backlog" }],
-    })
-    expect(resp.results[0].name).toBe("Backlog")
-  })
-})
+	it("decodes results", async () => {
+		const resp = await decode(StatesResponseSchema, {
+			results: [{ id: "s1", name: "Backlog", group: "backlog" }],
+		});
+		expect(resp.results[0].name).toBe("Backlog");
+	});
+});
 
 describe("ProjectSchema", () => {
-  it("decodes a project", async () => {
-    const p = await decode(ProjectSchema, { id: "p1", identifier: "ACME", name: "Acme Project" })
-    expect(p.identifier).toBe("ACME")
-  })
-
-  it("accepts optional description", async () => {
-    const p = await decode(ProjectSchema, {
-      id: "p1",
-      identifier: "ACME",
-      name: "InstUI",
-      description: "desc",
-    })
-    expect(p.description).toBe("desc")
-  })
-})
+	it("decodes a project", async () => {
+		const p = await decode(ProjectSchema, {
+			id: "p1",
+			identifier: "ACME",
+			name: "Acme Project",
+		});
+		expect(p.identifier).toBe("ACME");
+	});
+
+	it("accepts optional description", async () => {
+		const p = await decode(ProjectSchema, {
+			id: "p1",
+			identifier: "ACME",
+			name: "InstUI",
+			description: "desc",
+		});
+		expect(p.description).toBe("desc");
+	});
+});
 
 describe("ProjectsResponseSchema", () => {
-  it("decodes results", async () => {
-    const resp = await decode(ProjectsResponseSchema, {
-      results: [{ id: "p1", identifier: "WEB", name: "Web Project" }],
-    })
-    expect(resp.results[0].identifier).toBe("WEB")
-  })
-})
+	it("decodes results", async () => {
+		const resp = await decode(ProjectsResponseSchema, {
+			results: [{ id: "p1", identifier: "WEB", name: "Web Project" }],
+		});
+		expect(resp.results[0].identifier).toBe("WEB");
+	});
+});
 
 describe("LabelSchema", () => {
-  it("decodes a label", async () => {
-    const label = await decode(LabelSchema, { id: "l1", name: "bug" })
-    expect(label.name).toBe("bug")
-  })
-
-  it("accepts null color", async () => {
-    const label = await decode(LabelSchema, { id: "l1", name: "bug", color: null })
-    expect(label.color).toBeNull()
-  })
-})
+	it("decodes a label", async () => {
+		const label = await decode(LabelSchema, { id: "l1", name: "bug" });
+		expect(label.name).toBe("bug");
+	});
+
+	it("accepts null color", async () => {
+		const label = await decode(LabelSchema, {
+			id: "l1",
+			name: "bug",
+			color: null,
+		});
+		expect(label.color).toBeNull();
+	});
+});
 
 describe("LabelsResponseSchema", () => {
-  it("decodes results", async () => {
-    const resp = await decode(LabelsResponseSchema, {
-      results: [{ id: "l1", name: "bug" }],
-    })
-    expect(resp.results).toHaveLength(1)
-  })
-})
+	it("decodes results", async () => {
+		const resp = await decode(LabelsResponseSchema, {
+			results: [{ id: "l1", name: "bug" }],
+		});
+		expect(resp.results).toHaveLength(1);
+	});
+});
 
 describe("MemberSchema", () => {
-  it("decodes a member", async () => {
-    const m = await decode(MemberSchema, {
-      id: "u1",
-      display_name: "Aaron",
-      email: "aaron@example.com",
-    })
-    expect(m.display_name).toBe("Aaron")
-  })
-
-  it("accepts null email", async () => {
-    const m = await decode(MemberSchema, { id: "u1", display_name: "Aaron", email: null })
-    expect(m.email).toBeNull()
-  })
-})
+	it("decodes a member", async () => {
+		const m = await decode(MemberSchema, {
+			id: "u1",
+			display_name: "Aaron",
+			email: "aaron@example.com",
+		});
+		expect(m.display_name).toBe("Aaron");
+	});
+
+	it("accepts null email", async () => {
+		const m = await decode(MemberSchema, {
+			id: "u1",
+			display_name: "Aaron",
+			email: null,
+		});
+		expect(m.email).toBeNull();
+	});
+});
 
 describe("MembersResponseSchema (flat array)", () => {
-  it("decodes a flat array", async () => {
-    const members = await decode(MembersResponseSchema, [
-      { id: "u1", display_name: "Aaron" },
-      { id: "u2", display_name: "Bea" },
-    ])
-    expect(members).toHaveLength(2)
-  })
-})
+	it("decodes a flat array", async () => {
+		const members = await decode(MembersResponseSchema, [
+			{ id: "u1", display_name: "Aaron" },
+			{ id: "u2", display_name: "Bea" },
+		]);
+		expect(members).toHaveLength(2);
+	});
+});
 
 describe("CycleSchema", () => {
-  it("decodes a cycle", async () => {
-    const c = await decode(CycleSchema, { id: "c1", name: "Sprint 1" })
-    expect(c.name).toBe("Sprint 1")
-  })
-
-  it("accepts optional dates", async () => {
-    const c = await decode(CycleSchema, {
-      id: "c1",
-      name: "Sprint 1",
-      start_date: "2025-01-01",
-      end_date: "2025-01-14",
-    })
-    expect(c.start_date).toBe("2025-01-01")
-  })
-})
+	it("decodes a cycle", async () => {
+		const c = await decode(CycleSchema, { id: "c1", name: "Sprint 1" });
+		expect(c.name).toBe("Sprint 1");
+	});
+
+	it("accepts optional dates", async () => {
+		const c = await decode(CycleSchema, {
+			id: "c1",
+			name: "Sprint 1",
+			start_date: "2025-01-01",
+			end_date: "2025-01-14",
+		});
+		expect(c.start_date).toBe("2025-01-01");
+	});
+});
 
 describe("CyclesResponseSchema", () => {
-  it("decodes results", async () => {
-    const resp = await decode(CyclesResponseSchema, {
-      results: [{ id: "c1", name: "Sprint 1" }],
-    })
-    expect(resp.results[0].id).toBe("c1")
-  })
-})
+	it("decodes results", async () => {
+		const resp = await decode(CyclesResponseSchema, {
+			results: [{ id: "c1", name: "Sprint 1" }],
+		});
+		expect(resp.results[0].id).toBe("c1");
+	});
+});