The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 03:37 UTC
| 1 | import { describe, expect, it } from "@effect/vitest"; |
| 2 | import * as DateTime from "effect/DateTime"; |
| 3 | import * as Schema from "effect/Schema"; |
| 4 | |
| 5 | import { |
| 6 | ForwardCompatibleArray, |
| 7 | ForwardCompatibleUnion, |
| 8 | ForwardCompatibleUnionArray, |
| 9 | isUnknownUnionMember, |
| 10 | TrimmedNonEmptyString, |
| 11 | UnknownUnionMember, |
| 12 | } from "./baseSchemas.ts"; |
| 13 | |
| 14 | const at = "2026-10-05T00:00:00.000Z"; |
| 15 | const Shape = Schema.Union([ |
| 16 | Schema.Struct({ kind: Schema.Literal("circle"), radius: Schema.Number, at: Schema.DateTimeUtc }), |
| 17 | Schema.Struct({ kind: Schema.Literal("square"), side: Schema.Number }), |
| 18 | ]); |
| 19 | const members = Shape.members; |
| 20 | const fromWire = <S extends Schema.Top>(schema: S) => |
| 21 | Schema.decodeUnknownSync(Schema.toCodecJson(schema) as never) as (value: unknown) => S["Type"]; |
| 22 | |
| 23 | describe("ForwardCompatibleArray", () => { |
| 24 | it("decodes elements through their own codec and drops ones it cannot read", () => { |
| 25 | const decoded = fromWire(ForwardCompatibleArray(Shape))([ |
| 26 | { kind: "circle", radius: 1, at }, |
| 27 | { kind: "triangle" }, |
| 28 | { kind: "square", side: "wide" }, |
| 29 | ]); |
| 30 | expect(decoded).toHaveLength(1); |
| 31 | expect(DateTime.isDateTime((decoded[0] as { at: unknown }).at)).toBe(true); |
| 32 | }); |
| 33 | |
| 34 | const Named = ForwardCompatibleArray(Schema.Struct({ name: TrimmedNonEmptyString })); |
| 35 | |
| 36 | it("drops an element it cannot encode instead of failing the array", () => { |
| 37 | const encodeNamed = Schema.encodeUnknownSync(Schema.toCodecJson(Named)); |
| 38 | |
| 39 | const wire = JSON.parse( |
| 40 | JSON.stringify(encodeNamed([{ name: "a" }, { name: " " }, { name: "b" }])), |
| 41 | ); |
| 42 | expect(wire).toEqual([{ name: "a" }, { name: "b" }]); |
| 43 | expect(fromWire(Named)(wire)).toEqual([{ name: "a" }, { name: "b" }]); |
| 44 | }); |
| 45 | |
| 46 | it("still drops the null holes a server on an earlier build sends", () => { |
| 47 | expect(fromWire(Named)([{ name: "a" }, null, { name: "b" }])).toEqual([ |
| 48 | { name: "a" }, |
| 49 | { name: "b" }, |
| 50 | ]); |
| 51 | }); |
| 52 | }); |
| 53 | |
| 54 | describe("ForwardCompatibleUnion", () => { |
| 55 | const decode = fromWire(ForwardCompatibleUnion(members, "kind")); |
| 56 | |
| 57 | it("decodes a member from a newer server as unknown", () => { |
| 58 | const decoded = decode({ kind: "triangle", corners: 3 }); |
| 59 | expect(isUnknownUnionMember(decoded)).toBe(true); |
| 60 | expect(decoded).toEqual(new UnknownUnionMember("kind", "triangle")); |
| 61 | }); |
| 62 | |
| 63 | it("decodes known members in full, transformations included", () => { |
| 64 | const decoded = decode({ kind: "circle", radius: 1, at }); |
| 65 | expect(isUnknownUnionMember(decoded)).toBe(false); |
| 66 | expect(DateTime.isDateTime((decoded as { at: unknown }).at)).toBe(true); |
| 67 | }); |
| 68 | |
| 69 | it("still fails a known member whose payload is broken", () => { |
| 70 | expect(() => decode({ kind: "square", side: "wide" })).toThrow(); |
| 71 | }); |
| 72 | }); |
| 73 | |
| 74 | describe("ForwardCompatibleUnionArray", () => { |
| 75 | it("keeps a known member however its fields are named", () => { |
| 76 | const Flagged = Schema.Struct({ |
| 77 | kind: Schema.Literal("flag"), |
| 78 | _unknown: Schema.Literal(true), |
| 79 | tag: Schema.String, |
| 80 | value: Schema.String, |
| 81 | }); |
| 82 | const flag = { kind: "flag", _unknown: true, tag: "kind", value: "x" }; |
| 83 | expect(fromWire(ForwardCompatibleUnionArray([Flagged], "kind"))([flag])).toEqual([flag]); |
| 84 | }); |
| 85 | |
| 86 | const decode = fromWire(ForwardCompatibleUnionArray(members, "kind")); |
| 87 | |
| 88 | it("drops members a newer server added and keeps the rest", () => { |
| 89 | const decoded = decode([ |
| 90 | { kind: "triangle" }, |
| 91 | { kind: "circle", radius: 1, at }, |
| 92 | { kind: "square", side: 2 }, |
| 93 | ]); |
| 94 | expect(decoded.map((shape) => shape.kind)).toEqual(["circle", "square"]); |
| 95 | }); |
| 96 | |
| 97 | it("fails when a known member is broken, so real bugs stay visible", () => { |
| 98 | expect(() => decode([{ kind: "square", side: "wide" }])).toThrow(); |
| 99 | }); |
| 100 | }); |