@devries-cameron20 / t3code Mirror · read-only
Fork 0

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, 04:45 UTC

main
ts 147 lines 5.65 KB
Raw
1 import { describe, expect, it } from "@alchemy.run/test";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import * as PgClient from "@effect/sql-pg/PgClient";
4 import * as Effect from "effect/Effect";
5 import * as Redacted from "effect/Redacted";
6 import * as Result from "effect/Result";
7 import * as TestClock from "effect/testing/TestClock";
8 import {
9 closePrismaDevDatabase,
10 ensurePrismaDevDatabase,
11 } from "../../../prisma/src/internal/PrismaDevDatabase.ts";
12
13 const queryAnswer = Effect.fn(
14 function* (_connectionString: string) {
15 const sql = yield* PgClient.PgClient;
16 const rows = yield* sql<{ answer: number }>`select 42::int as answer`;
17 return Number(rows[0]?.answer);
18 },
19 (effect, connectionString) =>
20 effect.pipe(Effect.provide(PgClient.layer({ url: Redacted.make(connectionString) }))),
21 );
22
23 describe(
24 "Prisma dev database",
25 { tags: ["provider:prisma", "provider:prisma:database", "local"] },
26 () => {
27 it.effect(
28 "rejects non-positive migration timeouts",
29 () =>
30 Effect.gen(function* () {
31 const result = yield* ensurePrismaDevDatabase("dev:invalid-timeout", {
32 migrateTimeoutSeconds: 0,
33 }).pipe(Effect.result);
34
35 expect(Result.isFailure(result)).toBe(true);
36 if (Result.isFailure(result)) {
37 expect(String(result.failure)).toContain(
38 "migrateTimeoutSeconds must be a positive finite number",
39 );
40 }
41 }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
42 { tags: ["unit"] },
43 );
44
45 it.effect("starts @prisma/dev and returns usable direct and pooled URLs", () => {
46 const basePort = 58000 + (process.pid % 1000);
47 const databaseId = `dev:database:test-${process.pid}`;
48
49 return Effect.gen(function* () {
50 const attrs = yield* ensurePrismaDevDatabase(databaseId, {
51 provider: "@prisma/dev",
52 persistenceMode: "stateless",
53 port: basePort,
54 databasePort: basePort + 1,
55 shadowDatabasePort: basePort + 2,
56 });
57
58 expect(attrs).toBeDefined();
59 const direct = Redacted.value(attrs!.directConnectionString);
60 const pooled = Redacted.value(attrs!.pooledConnectionString);
61
62 expect(direct).toContain("127.0.0.1");
63 expect(pooled).toMatch(/^prisma\+postgres:\/\//);
64 expect(attrs!.host).toBe("127.0.0.1");
65
66 const answer = yield* queryAnswer(direct);
67 expect(answer).toBe(42);
68
69 expect(yield* ensurePrismaDevDatabase(databaseId, false)).toBeUndefined();
70 const afterDisable = yield* queryAnswer(direct).pipe(Effect.result);
71 expect(Result.isFailure(afterDisable)).toBe(true);
72 }).pipe(
73 Effect.ensuring(closePrismaDevDatabase(databaseId).pipe(Effect.orDie)),
74 Effect.scoped,
75 Effect.provide(NodeServices.layer),
76 );
77 });
78
79 it.effect("redacts migration failures and terminates commands at the timeout", () => {
80 const basePort = 59000 + (process.pid % 500);
81 const databaseId = `dev:migration-test-${process.pid}`;
82 const node = JSON.stringify(process.execPath);
83 const options = {
84 provider: "@prisma/dev" as const,
85 persistenceMode: "stateless" as const,
86 port: basePort,
87 databasePort: basePort + 1,
88 shadowDatabasePort: basePort + 2,
89 };
90
91 return Effect.gen(function* () {
92 const attrs = yield* ensurePrismaDevDatabase(databaseId, options);
93 expect(attrs).toBeDefined();
94 const direct = Redacted.value(attrs!.directConnectionString);
95 const pooled = Redacted.value(attrs!.pooledConnectionString);
96 const apiKey = new URL(pooled).searchParams.get("api_key");
97 expect(apiKey).toBeTruthy();
98
99 const failed = yield* ensurePrismaDevDatabase(databaseId, {
100 ...options,
101 migrate: `exec ${node} -e 'const url = new URL(process.env.DATABASE_URL); console.error(process.env.DATABASE_URL); console.error(url.searchParams.get("api_key")); process.exit(7)'`,
102 migrateTimeoutSeconds: 5,
103 }).pipe(Effect.result);
104 expect(Result.isFailure(failed)).toBe(true);
105 if (Result.isFailure(failed)) {
106 const message = String(failed.failure);
107 expect(message).toContain("exit code 7");
108 expect(message).toContain("[REDACTED]");
109 expect(message).not.toContain(direct);
110 expect(message).not.toContain(pooled);
111 expect(message).not.toContain(apiKey!);
112 expect(JSON.stringify(failed.failure)).not.toContain(apiKey!);
113 }
114
115 const overflow = yield* ensurePrismaDevDatabase(databaseId, {
116 ...options,
117 migrate: `exec ${node} -e 'process.stdout.write("x".repeat(1048577))'`,
118 migrateTimeoutSeconds: 5,
119 }).pipe(Effect.result);
120 expect(Result.isFailure(overflow)).toBe(true);
121 if (Result.isFailure(overflow)) {
122 expect(String(overflow.failure)).toContain(
123 "migration stdout exceeded the 1048576 byte safety limit",
124 );
125 }
126
127 const timedOut = yield* TestClock.withLive(
128 ensurePrismaDevDatabase(databaseId, {
129 ...options,
130 migrate: `exec ${node} -e 'setInterval(() => {}, 1000)'`,
131 migrateTimeoutSeconds: 0.1,
132 }),
133 ).pipe(Effect.result);
134 expect(Result.isFailure(timedOut)).toBe(true);
135 if (Result.isFailure(timedOut)) {
136 expect(String(timedOut.failure)).toContain(
137 "timed out after 0.1 seconds and was terminated",
138 );
139 }
140 }).pipe(
141 Effect.ensuring(closePrismaDevDatabase(databaseId).pipe(Effect.orDie)),
142 Effect.scoped,
143 Effect.provide(NodeServices.layer),
144 );
145 });
146 },
147 );