Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

commandPermissions.test.ts

596 lines23.6 KB

1import { requestGuarded, runStreamGuarded } from "../rpc/client.ts";
2import { EnvironmentSupervisor } from "../connection/supervisor.ts";
3import * as SubscriptionRef from "effect/SubscriptionRef";
4import * as Option from "effect/Option";
5import * as Stream from "effect/Stream";
6import type { RpcSession } from "../rpc/session.ts";
7import { describe, expect, it } from "@effect/vitest";
8import { vi } from "vite-plus/test";
9import {
10 AuthAccessReadScope,
11 AuthAccessWriteScope,
12 AuthEnvironmentMaintainScope,
13 AuthOrchestrationOperateScope,
14 AuthOrchestrationReadScope,
15 AuthPreviewOperateScope,
16 AuthProvidersManageScope,
17 AuthSettingsWriteScope,
18 AuthSourceControlWriteScope,
19 ThreadId,
20 EnvironmentId,
21 ORCHESTRATION_V2_WS_METHODS,
22 ScheduledTaskId,
23 WS_METHODS,
24 type AuthSessionState,
25 type PeerLinkSummary,
26} from "@t3tools/contracts";
27import * as Cause from "effect/Cause";
28import * as DateTime from "effect/DateTime";
29import * as Effect from "effect/Effect";
30import * as Fiber from "effect/Fiber";
31import * as Layer from "effect/Layer";
32import { Atom, AtomRegistry, AsyncResult } from "effect/reactivity";
33import { EnvironmentRegistry } from "../connection/registry.ts";
34import { createCommandPermissions } from "./commandPermissions.ts";
35import { createEnvironmentRpcCommand } from "./runtime.ts";
36import { AVAILABLE_CONNECTION_STATE, BearerConnectionTarget } from "../connection/model.ts";
37import { createPeerLinkEnvironmentAtoms } from "./peerLinks.ts";
38​
39vi.mock("./session.ts", () => ({
40 createEnvironmentSessionAtoms: () => ({ sessionStateAtom: sessions }),
41}));
42const sessions = Atom.family((_id: EnvironmentId) =>
43 Atom.make<AsyncResult.AsyncResult<AuthSessionState, string>>(AsyncResult.initial()),
44);
45const env = EnvironmentId.make("target");
46const other = EnvironmentId.make("other");
47const grant = (allowed: boolean): AuthSessionState => ({
48 authenticated: true,
49 auth: {
50 policy: "remote-reachable",
51 bootstrapMethods: [],
52 sessionMethods: [],
53 sessionCookieName: "test",
54 },
55 scopes: allowed ? [AuthOrchestrationOperateScope] : [],
56 permissions: allowed ? [AuthOrchestrationOperateScope] : [],
57});
58const runtime = Atom.runtime(
59 Layer.succeed(EnvironmentRegistry, {
60 run: (_id: EnvironmentId, effect: Effect.Effect<unknown>) => effect,
61 } as unknown as EnvironmentRegistry["Service"]),
62);
63const permissions = createCommandPermissions(runtime, WS_METHODS.scheduledTasksDelete);
64const setup = Effect.gen(function* () {
65 const registry = AtomRegistry.make();
66 registry.mount(sessions(env));
67 yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose()));
68 return registry;
69});
70​
71describe("command permissions", () => {
72 it.effect("requires the destination read grant to refresh providers", () =>
73 Effect.scoped(
74 Effect.gen(function* () {
75 const registry = yield* setup;
76 const refresh = createCommandPermissions(runtime, WS_METHODS.serverRefreshProviders);
77 registry.set(sessions(env), AsyncResult.success(grant(true)));
78 expect(registry.get(refresh.permissionAtom(env))).toBe(false);
79 expect((yield* refresh.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
80 "EnvironmentAuthorizationError",
81 );
82 registry.set(
83 sessions(env),
84 AsyncResult.success({
85 ...grant(false),
86 scopes: [AuthOrchestrationReadScope],
87 permissions: [AuthOrchestrationReadScope],
88 }),
89 );
90 expect(registry.get(refresh.permissionAtom(env))).toBe(true);
91 yield* refresh.authorize(registry, env);
92 registry.set(sessions(other), AsyncResult.success(grant(false)));
93 expect(registry.get(refresh.permissionAtom(other))).toBe(false);
94 expect((yield* refresh.authorize(registry, other).pipe(Effect.flip))._tag).toBe(
95 "EnvironmentAuthorizationError",
96 );
97 registry.set(sessions(env), AsyncResult.success(grant(false)));
98 expect(registry.get(refresh.permissionAtom(env))).toBe(false);
99 expect((yield* refresh.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
100 "EnvironmentAuthorizationError",
101 );
102 }),
103 ),
104 );
105​
106 it.effect("requires the destination preview grant to close a browser tab", () =>
107 Effect.scoped(
108 Effect.gen(function* () {
109 const registry = yield* setup;
110 const close = createCommandPermissions(runtime, WS_METHODS.previewClose);
111 registry.set(sessions(env), AsyncResult.success(grant(true)));
112 expect(registry.get(close.permissionAtom(env))).toBe(false);
113 expect((yield* close.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
114 "EnvironmentAuthorizationError",
115 );
116 registry.set(
117 sessions(env),
118 AsyncResult.success({
119 ...grant(false),
120 scopes: [AuthPreviewOperateScope],
121 permissions: [AuthPreviewOperateScope],
122 }),
123 );
124 expect(registry.get(close.permissionAtom(env))).toBe(true);
125 yield* close.authorize(registry, env);
126 registry.set(sessions(other), AsyncResult.success(grant(false)));
127 expect(registry.get(close.permissionAtom(other))).toBe(false);
128 expect((yield* close.authorize(registry, other).pipe(Effect.flip))._tag).toBe(
129 "EnvironmentAuthorizationError",
130 );
131 }),
132 ),
133 );
134​
135 it.effect("requires the destination provider grant to remove an incomplete connection", () =>
136 Effect.scoped(
137 Effect.gen(function* () {
138 const registry = yield* setup;
139 const remove = createCommandPermissions(runtime, WS_METHODS.providerAuthRemoveMethod);
140 registry.set(sessions(env), AsyncResult.success(grant(true)));
141 expect(registry.get(remove.permissionAtom(env))).toBe(false);
142 expect((yield* remove.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
143 "EnvironmentAuthorizationError",
144 );
145 registry.set(
146 sessions(env),
147 AsyncResult.success({
148 ...grant(false),
149 scopes: [AuthProvidersManageScope],
150 permissions: [AuthProvidersManageScope],
151 }),
152 );
153 expect(registry.get(remove.permissionAtom(env))).toBe(true);
154 yield* remove.authorize(registry, env);
155 registry.set(sessions(other), AsyncResult.success(grant(false)));
156 expect(registry.get(remove.permissionAtom(other))).toBe(false);
157 }),
158 ),
159 );
160​
161 it.effect.each([
162 { method: WS_METHODS.serverRunStorageCleanup, scope: AuthSettingsWriteScope },
163 { method: WS_METHODS.serverReclaimDatabaseSpace, scope: AuthEnvironmentMaintainScope },
164 ])("requires the destination $scope grant for $method", ({ method, scope }) =>
165 Effect.scoped(
166 Effect.gen(function* () {
167 const registry = yield* setup;
168 const command = createCommandPermissions(runtime, method);
169 registry.set(sessions(env), AsyncResult.success(grant(true)));
170 expect(registry.get(command.permissionAtom(env))).toBe(false);
171 expect((yield* command.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
172 "EnvironmentAuthorizationError",
173 );
174 registry.set(
175 sessions(env),
176 AsyncResult.success({ ...grant(true), scopes: [scope], permissions: [scope] }),
177 );
178 expect(registry.get(command.permissionAtom(env))).toBe(true);
179 yield* command.authorize(registry, env);
180 registry.set(sessions(other), AsyncResult.success(grant(false)));
181 expect(registry.get(command.permissionAtom(other))).toBe(false);
182 }),
183 ),
184 );
185​
186 it.effect.each([WS_METHODS.serverCheckOtlpEndpoint, WS_METHODS.serverCheckSecretSource])(
187 "requires the destination settings grant for %s",
188 (method) =>
189 Effect.scoped(
190 Effect.gen(function* () {
191 const registry = yield* setup;
192 const check = createCommandPermissions(runtime, method);
193 registry.set(sessions(env), AsyncResult.success(grant(true)));
194 expect(registry.get(check.permissionAtom(env))).toBe(false);
195 registry.set(
196 sessions(env),
197 AsyncResult.success({
198 ...grant(false),
199 scopes: [AuthSettingsWriteScope],
200 permissions: [AuthSettingsWriteScope],
201 }),
202 );
203 expect(registry.get(check.permissionAtom(env))).toBe(true);
204 yield* check.authorize(registry, env);
205 }),
206 ),
207 );
208​
209 it.effect.each([WS_METHODS.scheduledTasksDelete, ORCHESTRATION_V2_WS_METHODS.stopWorkflow])(
210 "uses the target grant for both availability and execution of %s",
211 (method) =>
212 Effect.scoped(
213 Effect.gen(function* () {
214 const registry = yield* setup;
215 const permissions = createCommandPermissions(runtime, method);
216 registry.set(sessions(env), AsyncResult.success(grant(true)));
217 expect(registry.get(permissions.permissionAtom(env))).toBe(true);
218 expect(permissions.permissionAtom(env)).toBe(permissions.permissionAtom(env));
219 yield* permissions.authorize(registry, env);
220 registry.set(sessions(other), AsyncResult.success(grant(false)));
221 expect(registry.get(permissions.permissionAtom(other))).toBe(false);
222 const denied = yield* permissions.authorize(registry, other).pipe(Effect.flip);
223 expect(denied._tag).toBe("EnvironmentAuthorizationError");
224 }),
225 ),
226 );
227 it.effect("waits for an initial grant", () =>
228 Effect.scoped(
229 Effect.gen(function* () {
230 const registry = yield* setup;
231 const fiber = yield* permissions.authorize(registry, env).pipe(Effect.forkChild);
232 yield* Effect.yieldNow;
233 registry.set(sessions(env), AsyncResult.success(grant(true)));
234 yield* Fiber.join(fiber);
235 }),
236 ),
237 );
238 it.effect(
239 "denies failed and unauthenticated sessions, but accepts a cached refreshing grant",
240 () =>
241 Effect.scoped(
242 Effect.gen(function* () {
243 const registry = yield* setup;
244 registry.set(sessions(env), AsyncResult.failure(Cause.fail("offline")));
245 expect((yield* permissions.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
246 "EnvironmentAuthorizationError",
247 );
248 registry.set(
249 sessions(env),
250 AsyncResult.success({ ...grant(true), authenticated: false }),
251 );
252 expect((yield* permissions.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
253 "EnvironmentAuthorizationError",
254 );
255 registry.set(sessions(env), AsyncResult.waiting(AsyncResult.success(grant(true))));
256 yield* permissions.authorize(registry, env);
257 }),
258 ),
259 );
260 it("rechecks permission after waiting in a serial command lane", async () => {
261 const registry = AtomRegistry.make();
262 const unmount = registry.mount(sessions(env));
263 registry.set(sessions(env), AsyncResult.success(grant(true)));
264 let release!: () => void;
265 let started!: () => void;
266 const entered = new Promise<void>((resolve) => {
267 started = resolve;
268 });
269 const gate = new Promise<void>((resolve) => {
270 release = resolve;
271 });
272 let calls = 0;
273 const command = createEnvironmentRpcCommand(runtime, {
274 label: "test.delete",
275 tag: WS_METHODS.scheduledTasksDelete,
276 concurrency: { mode: "serial", key: () => "target" },
277 execute: () =>
278 Effect.promise(async () => {
279 calls++;
280 started();
281 await gate;
282 return { id: ScheduledTaskId.make("task") };
283 }),
284 });
285 const target = { environmentId: env, input: { id: ScheduledTaskId.make("task") } };
286 try {
287 const first = command.run(registry, target);
288 await entered;
289 const second = command.run(registry, target);
290 registry.set(sessions(env), AsyncResult.success(grant(false)));
291 release();
292 expect((await first)._tag).toBe("Success");
293 expect((await second)._tag).toBe("Failure");
294 expect(calls).toBe(1);
295 } finally {
296 unmount();
297 registry.dispose();
298 }
299 });
300});
301​
302it.effect(
303 "requires source control alone for git, and both grants when attaching a worktree to a thread",
304 () =>
305 Effect.scoped(
306 Effect.gen(function* () {
307 const registry = yield* setup;
308 registry.set(sessions(env), AsyncResult.success(grant(true)));
309 const git = createCommandPermissions(runtime, WS_METHODS.vcsInit);
310 expect((yield* git.authorize(registry, env).pipe(Effect.flip)).requiredPermission).toBe(
311 AuthSourceControlWriteScope,
312 );
313 registry.set(
314 sessions(env),
315 AsyncResult.success({
316 ...grant(false),
317 scopes: [AuthSourceControlWriteScope],
318 permissions: [AuthSourceControlWriteScope],
319 }),
320 );
321 yield* git.authorize(registry, env);
322 const prepare = createCommandPermissions(runtime, WS_METHODS.gitPreparePullRequestThread);
323 const input = {
324 cwd: "/repo",
325 reference: "123",
326 mode: "worktree",
327 threadId: ThreadId.make("thread"),
328 };
329 expect(registry.get(prepare.permissionAtom(env, input))).toBe(false);
330 expect(
331 (yield* prepare.authorize(registry, env, input).pipe(Effect.flip)).requiredScope,
332 ).toBe(AuthOrchestrationOperateScope);
333 yield* prepare.authorize(registry, env, { ...input, threadId: undefined });
334 registry.set(
335 sessions(env),
336 AsyncResult.success({
337 ...grant(true),
338 scopes: [AuthSourceControlWriteScope, AuthOrchestrationOperateScope],
339 permissions: [AuthSourceControlWriteScope, AuthOrchestrationOperateScope],
340 }),
341 );
342 expect(registry.get(prepare.permissionAtom(env, input))).toBe(true);
343 yield* prepare.authorize(registry, env, input);
344 }),
345 ),
346);
347​
348it.effect.each(["commit", "push", "commit_push", "create_pr", "commit_push_pr"] as const)(
349 "%s needs thread read permission only when generating a PR from a thread",
350 (action) =>
351 Effect.scoped(
352 Effect.gen(function* () {
353 const registry = yield* setup;
354 const command = createCommandPermissions(runtime, WS_METHODS.gitRunStackedAction);
355 const input = { actionId: "action", cwd: "/repo", action };
356 const withThread = { ...input, threadId: ThreadId.make("thread") };
357 const session = {
358 ...grant(false),
359 scopes: [AuthSourceControlWriteScope],
360 permissions: [AuthSourceControlWriteScope],
361 };
362 registry.set(sessions(env), AsyncResult.success(session));
363 expect(registry.get(command.permissionAtom(env, input))).toBe(true);
364 yield* command.authorize(registry, env, input);
365 const readsThread = action === "create_pr" || action === "commit_push_pr";
366 expect(registry.get(command.permissionAtom(env, withThread))).toBe(!readsThread);
367 if (readsThread) {
368 expect(
369 yield* command.authorize(registry, env, withThread).pipe(Effect.flip),
370 ).toMatchObject({ requiredPermission: AuthOrchestrationReadScope });
371 } else {
372 yield* command.authorize(registry, env, withThread);
373 }
374 registry.set(
375 sessions(env),
376 AsyncResult.success({
377 ...session,
378 scopes: [AuthSourceControlWriteScope, AuthOrchestrationReadScope],
379 permissions: [AuthSourceControlWriteScope, AuthOrchestrationReadScope],
380 }),
381 );
382 expect(registry.get(command.permissionAtom(env, withThread))).toBe(true);
383 yield* command.authorize(registry, env, withThread);
384 }),
385 ),
386);
387​
388it.effect(
389 "refreshes linked environments after permitted writes and blocks a read-only session",
390 () =>
391 Effect.scoped(
392 Effect.gen(function* () {
393 const registry = yield* setup;
394 const peer: PeerLinkSummary = {
395 environmentId: EnvironmentId.make("peer"),
396 label: "Box",
397 urls: ["https://box.example.test"],
398 access: "auto",
399 linkedAt: DateTime.makeUnsafe("2026-10-01T12:00:00Z"),
400 expiresAt: DateTime.makeUnsafe("2026-10-31T12:00:00Z"),
401 lastReachedAt: null,
402 lastError: null,
403 status: "reachable",
404 };
405 let links: ReadonlyArray<PeerLinkSummary> = [];
406 const client = {
407 [WS_METHODS.peerLinksList]: () => Effect.sync(() => ({ links })),
408 [WS_METHODS.peerLinksLink]: vi.fn(() =>
409 Effect.sync(() => {
410 links = [peer];
411 return peer;
412 }),
413 ),
414 [WS_METHODS.peerLinksUnlink]: vi.fn(() =>
415 Effect.sync(() => {
416 links = [];
417 return { removed: true };
418 }),
419 ),
420 };
421 const supervisor = {
422 target: new BearerConnectionTarget({
423 environmentId: env,
424 label: "Test",
425 connectionId: "test",
426 }),
427 session: yield* SubscriptionRef.make(Option.some({ client } as unknown as RpcSession)),
428 state: yield* SubscriptionRef.make({
429 ...AVAILABLE_CONNECTION_STATE,
430 phase: "connected" as const,
431 }),
432 } as EnvironmentSupervisor["Service"];
433 const peerRuntime = Atom.runtime(
434 Layer.succeed(EnvironmentRegistry, {
435 run: (id, effect) => {
436 expect(id).toBe(env);
437 return Effect.provideService(effect, EnvironmentSupervisor, supervisor);
438 },
439 followStream: (id, stream) => {
440 expect(id).toBe(env);
441 return Stream.provideService(stream, EnvironmentSupervisor, supervisor);
442 },
443 } as EnvironmentRegistry["Service"]),
444 );
445 const peerLinks = createPeerLinkEnvironmentAtoms(peerRuntime);
446 const list = peerLinks.list({ environmentId: env, input: {} });
447 registry.mount(list);
448 const readLinks = AtomRegistry.getResult(registry, list, { suspendOnWaiting: true });
449 const setAccess = (writable: boolean) =>
450 registry.set(
451 sessions(env),
452 AsyncResult.success({
453 ...grant(false),
454 scopes: [AuthAccessReadScope, ...(writable ? [AuthAccessWriteScope] : [])],
455 permissions: [AuthAccessReadScope, ...(writable ? [AuthAccessWriteScope] : [])],
456 }),
457 );
458 registry.mount(sessions(other));
459 registry.set(
460 sessions(other),
461 AsyncResult.success({
462 ...grant(false),
463 scopes: [AuthAccessWriteScope],
464 permissions: [AuthAccessWriteScope],
465 }),
466 );
467 setAccess(false);
468 expect(yield* readLinks).toEqual({ links: [] });
469 const linkInput = { url: peer.urls[0]!, pairingCode: "test-code", access: peer.access };
470 const link = Effect.promise(() =>
471 peerLinks.link.run(registry, { environmentId: env, input: linkInput }),
472 );
473 const unlink = Effect.promise(() =>
474 peerLinks.unlink.run(registry, {
475 environmentId: env,
476 input: { environmentId: peer.environmentId },
477 }),
478 );
479 expect(registry.get(peerLinks.link.permissionAtom(env))).toBe(false);
480 const deniedLink = yield* link;
481 expect(deniedLink._tag).toBe("Failure");
482 if (deniedLink._tag === "Failure") {
483 expect(Cause.squash(deniedLink.cause)).toMatchObject({
484 _tag: "EnvironmentAuthorizationError",
485 requiredPermission: AuthAccessWriteScope,
486 });
487 }
488 expect(client[WS_METHODS.peerLinksLink]).not.toHaveBeenCalled();
489 setAccess(true);
490 expect(registry.get(peerLinks.link.permissionAtom(env))).toBe(true);
491 expect((yield* link)._tag).toBe("Success");
492 expect(client[WS_METHODS.peerLinksLink]).toHaveBeenCalledExactlyOnceWith(linkInput);
493 expect(yield* readLinks).toEqual({ links: [peer] });
494​
495 setAccess(false);
496 expect(registry.get(peerLinks.unlink.permissionAtom(env))).toBe(false);
497 const deniedUnlink = yield* unlink;
498 expect(deniedUnlink._tag).toBe("Failure");
499 if (deniedUnlink._tag === "Failure") {
500 expect(Cause.squash(deniedUnlink.cause)).toMatchObject({
501 _tag: "EnvironmentAuthorizationError",
502 requiredPermission: AuthAccessWriteScope,
503 });
504 }
505 expect(client[WS_METHODS.peerLinksUnlink]).not.toHaveBeenCalled();
506 expect(yield* readLinks).toEqual({ links: [peer] });
507 setAccess(true);
508 expect(registry.get(peerLinks.unlink.permissionAtom(env))).toBe(true);
509 expect((yield* unlink)._tag).toBe("Success");
510 expect(client[WS_METHODS.peerLinksUnlink]).toHaveBeenCalledExactlyOnceWith({
511 environmentId: peer.environmentId,
512 });
513 expect(yield* readLinks).toEqual({ links: [] });
514 }),
515 ),
516);
517​
518it.effect("requires access management to answer a link request", () =>
519 Effect.scoped(
520 Effect.gen(function* () {
521 const registry = yield* setup;
522 registry.set(sessions(env), AsyncResult.success(grant(true)));
523 const answer = createCommandPermissions(runtime, WS_METHODS.peerLinksAnswerRequest);
524 expect(registry.get(answer.permissionAtom(env))).toBe(false);
525 expect((yield* answer.authorize(registry, env).pipe(Effect.flip)).requiredPermission).toBe(
526 AuthAccessWriteScope,
527 );
528 registry.set(
529 sessions(env),
530 AsyncResult.success({
531 ...grant(false),
532 scopes: [AuthAccessWriteScope],
533 permissions: [AuthAccessWriteScope],
534 }),
535 );
536 expect(registry.get(answer.permissionAtom(env))).toBe(true);
537 yield* answer.authorize(registry, env);
538 }),
539 ),
540);
541​
542it.effect("honors exact empty permissions and preserves legacy parent grants", () =>
543 Effect.scoped(
544 Effect.gen(function* () {
545 const registry = yield* setup;
546 const git = createCommandPermissions(runtime, WS_METHODS.vcsInit);
547 registry.set(sessions(env), AsyncResult.success({ ...grant(true), permissions: [] }));
548 expect(registry.get(git.permissionAtom(env))).toBe(false);
549 const denied = yield* git.authorize(registry, env).pipe(Effect.flip);
550 expect(denied).toMatchObject({
551 requiredPermission: AuthSourceControlWriteScope,
552 requiredScope: AuthOrchestrationOperateScope,
553 });
554 const { permissions: _exact, ...legacy } = grant(true);
555 registry.set(sessions(env), AsyncResult.success(legacy));
556 expect(registry.get(git.permissionAtom(env))).toBe(true);
557 yield* git.authorize(registry, env);
558 }),
559 ),
560);
561​
562it.effect("rejects protected unary and streamed RPCs outside a guarded command", () =>
563 Effect.gen(function* () {
564 let writes = 0;
565 const session = {
566 client: {
567 [WS_METHODS.scheduledTasksDelete]: () =>
568 Effect.sync(() => {
569 writes++;
570 return { id: ScheduledTaskId.make("task") };
571 }),
572 [WS_METHODS.gitRunStackedAction]: () =>
573 Stream.fromEffect(
574 Effect.sync(() => {
575 writes++;
576 }),
577 ),
578 },
579 } as unknown as RpcSession;
580 const supervisor = {
581 target: { environmentId: env, label: "target" },
582 session: yield* SubscriptionRef.make(Option.some(session)),
583 } as unknown as EnvironmentSupervisor["Service"];
584 const unary = yield* requestGuarded(WS_METHODS.scheduledTasksDelete, {
585 id: ScheduledTaskId.make("task"),
586 }).pipe(Effect.provideService(EnvironmentSupervisor, supervisor), Effect.flip);
587 expect(unary._tag).toBe("EnvironmentAuthorizationError");
588 const streamed = yield* runStreamGuarded(WS_METHODS.gitRunStackedAction, {
589 actionId: "test-action",
590 cwd: "/repo",
591 action: "commit",
592 }).pipe(Stream.runDrain, Effect.provideService(EnvironmentSupervisor, supervisor), Effect.flip);
593 expect(streamed._tag).toBe("EnvironmentAuthorizationError");
594 expect(writes).toBe(0);
595 }),
596);