alchemy 2.0.0-beta.25 → 2.0.0-beta.26

package/src/Test/Vitest.ts

@@ -1,543 +1,191 @@
-import type * as aws from "@distilled.cloud/aws";
-import * as cf from "@distilled.cloud/cloudflare";
-// import { NodeServices } from "@effect/platform-node";
-import { expect, it } from "@effect/vitest";
-import { Logger } from "effect";
-import * as Config from "effect/Config";
-import * as ConfigProvider from "effect/ConfigProvider";
+import { it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { MinimumLogLevel } from "effect/References";
-import * as Scope from "effect/Scope";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as NodePath from "node:path";
 import {
   afterAll as vitestAfterAll,
+  afterEach as vitestAfterEach,
   beforeAll as vitestBeforeAll,
+  beforeEach as vitestBeforeEach,
 } from "vitest";
-import * as AWS from "../AWS/index.ts";
-import * as Cloudflare from "../Cloudflare/index.ts";
 
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
-import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
-import { apply } from "../Apply.ts";
-import { Artifacts, provideFreshArtifactStore } from "../Artifacts.ts";
-import { AuthProviders } from "../Auth/AuthProvider.ts";
-import * as AWSCredentials from "../AWS/Credentials.ts";
-import * as AWSEnvironment from "../AWS/Environment.ts";
-import * as AWSRegion from "../AWS/Region.ts";
-import type { Command } from "../Build/Command.ts";
-import type { Cli } from "../Cli/index.ts";
-import { LoggingCli } from "../Cli/LoggingCli.ts";
-import {
-  buildNamespaceTree,
-  flattenTree,
-  type DerivedAction,
-} from "../Cli/NamespaceTree.ts";
-import { ExecutionContext } from "../ExecutionContext.ts";
-import type { Input } from "../Input.ts";
-import type { Output } from "../Output.ts";
-import * as Plan from "../Plan.ts";
-import type { Provider } from "../Provider.ts";
-import * as Server from "../Server/index.ts";
-import * as Serverless from "../Serverless/index.ts";
-import * as Stack from "../Stack.ts";
-import * as Stage from "../Stage.ts";
-import * as State from "../State/index.ts";
-import { PlatformServices } from "../Util/PlatformServices.ts";
-
-export const expectEmptyObject = () =>
-  expect.toSatisfy(
-    (deletions) => Object.keys(deletions).length === 0,
-    "empty object",
-  );
-
-export const expectPropExpr = (identifier: string, src: any) =>
-  expect.objectContaining({
-    kind: "PropExpr",
-    identifier,
-    expr: expect.objectContaining({
-      kind: "ResourceExpr",
-      src,
-    }),
-  });
-
-type Provided =
-  | Scope.Scope
-  | Stack.Stack
-  | State.State
-  | Stage.Stage
-  | AlchemyContext
-  | HttpClient.HttpClient
-  | FileSystem.FileSystem
-  | Path.Path
-  | aws.Credentials.Credentials
-  | aws.Region.Region
-  | Cli
-  | ExecutionContext
-  | Server.ProcessContext
-  | Server.ServerHost
-  | Serverless.FunctionContext
-  | AWSEnvironment.AWSEnvironment
-  | Artifacts
-  | Provider<Command>
-  | AWS.Providers
-  | Cloudflare.Providers
-  | ChildProcessSpawner
-  | AuthProviders;
-
-const quietLogger = Logger.make(() => {
-  // console.log(options.message);
-});
-
-const platform = Layer.mergeAll(
-  PlatformServices,
-  FetchHttpClient.layer,
-  Logger.layer([process.env.VERBOSE ? Logger.consolePretty() : quietLogger]),
-);
-
-const awsEnvironment = Layer.unwrap(
-  Effect.gen(function* () {
-    const _profileName = yield* Config.string("AWS_PROFILE").pipe(
-      Config.withDefault("default"),
-    );
-    const LOCAL = yield* Config.boolean("LOCAL").pipe(
-      Config.withDefault(false),
-    );
-    const LOCALSTACK_ENDPOINT = yield* Config.string(
-      "LOCALSTACK_ENDPOINT",
-    ).pipe(Config.withDefault("http://localhost.localstack.cloud:4566"));
-
-    if (LOCAL) {
-      return AWSEnvironment.makeEnvironment({
-        accountId: "000000000000",
-        region: "us-east-1",
-        credentials: {
-          accessKeyId: "test",
-          secretAccessKey: "test",
-          sessionToken: "test",
-        },
-        endpoint: LOCALSTACK_ENDPOINT,
-      });
-    }
-    return Layer.effect(
-      AWSEnvironment.AWSEnvironment,
-      AWSEnvironment.loadDefault(),
-    ).pipe(Layer.orDie);
-  }),
-);
-
-const awsProviders = Layer.provideMerge(
-  AWS.providers(),
-  Layer.provideMerge(
-    Layer.mergeAll(AWSRegion.fromEnvironment, AWSCredentials.fromEnvironment),
-    awsEnvironment,
-  ),
-);
-
-const cfProviders = Layer.provideMerge(
-  Cloudflare.providers(),
-  Layer.mergeAll(cf.CredentialsFromEnv, FetchHttpClient.layer),
-);
-
-const deriveStackName = (testPath: string, suffix: string) => {
-  const testDir = testPath.includes("/test/")
-    ? (testPath.split("/test/").pop() ?? "")
-    : NodePath.basename(testPath);
-  const testPathWithoutExt = testDir.replace(/\.[^.]+$/, "");
-  return `${testPathWithoutExt}-${suffix}`
-    .replaceAll(/[^a-zA-Z0-9_]/g, "-")
-    .replace(/-+/g, "-");
-};
-
-const runWithContext = <A, Err>(
-  stackName: string,
-  effect: Effect.Effect<A, Err, Provided>,
-  options: {
-    state?: Layer.Layer<State.State, never, Stack.Stack>;
-    providers?: boolean;
-  } = {},
-): Effect.Effect<
-  A,
-  aws.Credentials.CredentialsError | Config.ConfigError | Err,
-  never
-> => {
-  const stack = Layer.effect(
-    Stack.Stack,
-    Effect.succeed({
-      name: stackName,
-      stage: "test",
-      resources: {},
-      bindings: {},
-    }),
-  );
-
-  const alchemy = Layer.provideMerge(
-    Layer.mergeAll(options.state ?? State.localState(), LoggingCli),
-    Layer.mergeAll(stack, AlchemyContextLive),
-  );
-
-  const context = {
-    Type: "Test",
-    id: "Test",
-    env: {},
-    exports: {},
-    listen: () => Effect.void,
-    serve: () => Effect.void,
-    get: <T>(_key: string) => Effect.succeed<T>(undefined as T),
-    set: (_id: string, _output: Output) =>
-      Effect.sync(() => _id.replaceAll(/[^a-zA-Z0-9]/g, "_")),
-  };
-
-  // Test harness does not fully close `Req`; runtime provides enough for tests.
-  // @ts-expect-error Residual requirement channel on `effect` after ConfigProvider.
-  return Effect.gen(function* () {
-    const configProvider = ConfigProvider.orElse(
-      yield* ConfigProvider.fromDotEnv({ path: ".env" }),
-      ConfigProvider.fromEnv(),
-    );
-    return yield* effect.pipe(
-      Effect.provideService(ConfigProvider.ConfigProvider, configProvider),
-    );
-  }).pipe(
-    Effect.provide(
-      Layer.provideMerge(
-        options.providers === false
-          ? Layer.empty
-          : Layer.mergeAll(awsProviders, cfProviders),
-        Layer.provideMerge(alchemy, platform),
-      ),
-    ),
-    Effect.provideService(Stage.Stage, "test"),
-    Effect.provideService(AuthProviders, {}),
-    Effect.provideService(ExecutionContext, context as any),
-    Effect.provideService(Server.ServerHost, {
-      run: (_effect) => Effect.void,
-    }),
-    Effect.provideService(
-      MinimumLogLevel,
-      process.env.DEBUG ? "Debug" : "Info",
-    ),
-    Effect.provide(PlatformServices),
-  );
-};
-
-export function test(
-  name: string,
-  options: {
-    timeout?: number;
-    state?: Layer.Layer<State.State, never, Stack.Stack>;
-    providers?: boolean;
-  },
-  testCase: Effect.Effect<void, any, Provided>,
-): void;
-
-export function test(
-  name: string,
-  testCase: Effect.Effect<void, any, Provided>,
-): void;
-
-export function test(
-  name: string,
-  ...args:
-    | [
-        {
-          timeout?: number;
-          state?: Layer.Layer<State.State, never, Stack.Stack>;
-          providers?: boolean;
-        },
-        Effect.Effect<void, any, Provided>,
-      ]
-    | [Effect.Effect<void, any, Provided>]
-) {
-  const [options = {}, testCase] =
-    args.length === 1 ? [undefined, args[0]] : args;
-
-  const testPath = expect.getState().testPath ?? "";
-  const stackName = deriveStackName(testPath, name);
-  const effect = runWithContext(stackName, testCase, options);
-
-  return it.live(name, () => effect, options.timeout);
+import type { AlchemyContext } from "../AlchemyContext.ts";
+import type { CompiledStack } from "../Stack.ts";
+import type { Stage } from "../Stage.ts";
+import * as Core from "./Core.ts";
+
+export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
+export type ScratchStack = Core.ScratchStack;
+export type TestEffect<A, R = never> = Core.TestEffect<A, R>;
+
+type TestOptions = number | { timeout?: number };
+
+const timeoutOf = (opts: TestOptions | undefined): number | undefined =>
+  typeof opts === "number" ? opts : opts?.timeout;
+
+interface TestFn {
+  (name: string, eff: TestEffect<void>, options?: TestOptions): void;
+  skip: (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
+  skipIf: (
+    condition: boolean,
+  ) => (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
+  only: (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
+  todo: (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
+  provider: ProviderFn;
 }
 
-export namespace test {
-  export function skip(
+interface ProviderFn {
+  (
     name: string,
-    options: {
-      timeout?: number;
-      state?: Layer.Layer<State.State, never, Stack.Stack>;
-      providers?: boolean;
-    },
-    testCase: Effect.Effect<void, any, Provided>,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: TestOptions,
   ): void;
-
-  export function skip(
+  skip: (
     name: string,
-    testCase: Effect.Effect<void, any, Provided>,
-  ): void;
-
-  export function skip(
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: TestOptions,
+  ) => void;
+  skipIf: (
+    condition: boolean,
+  ) => (
     name: string,
-    ...args:
-      | [
-          {
-            timeout?: number;
-            state?: Layer.Layer<State.State, never, Stack.Stack>;
-            providers?: boolean;
-          },
-          Effect.Effect<void, any, Provided>,
-        ]
-      | [Effect.Effect<void, any, Provided>]
-  ) {
-    const [options = {}, _testCase] =
-      args.length === 1 ? [undefined, args[0]] : args;
-    it.skip(name, () => {}, options.timeout);
-  }
-
-  export function skipIf(condition: boolean) {
-    return function (
-      name: string,
-      ...args:
-        | [
-            {
-              timeout?: number;
-              state?: Layer.Layer<State.State, never, Stack.Stack>;
-              providers?: boolean;
-            },
-            Effect.Effect<void, any, Provided>,
-          ]
-        | [Effect.Effect<void, any, Provided>]
-    ) {
-      if (condition) {
-        const [options = {}, _testCase] =
-          args.length === 1 ? [undefined, args[0]] : args;
-        it.skip(name, () => {}, options.timeout);
-      } else {
-        test(name, ...(args as [Effect.Effect<void, any, Provided>]));
-      }
-    };
-  }
-
-  export const state = (resources: Record<string, State.ResourceState> = {}) =>
-    Layer.effect(
-      State.State,
-      Effect.gen(function* () {
-        const stack = yield* Stack.Stack;
-        return State.InMemoryService({
-          [stack.name]: {
-            [stack.stage]: resources,
-          },
-        });
-      }),
-    );
-
-  export const defaultState = (
-    resources: Record<string, State.ResourceState> = {},
-    other?: {
-      [stack: string]: {
-        [stage: string]: {
-          [resourceId: string]: State.ResourceState;
-        };
-      };
-    },
-  ) =>
-    Layer.succeed(
-      State.State,
-      State.InMemoryService({
-        ["test-app"]: {
-          ["test-stage"]: resources,
-        },
-        ...other,
-      }),
-    );
-
-  export const deploy = <A, Err = never, Req = any>(
-    effect: Effect.Effect<A, Err, Req>,
-  ): Effect.Effect<Input.Resolve<A>, Err, Req | Stack.Stack> =>
-    Stack.Stack.use((stack) =>
-      effect.pipe(
-        // @ts-expect-error - test harness reuses ambient runtime context
-        Stack.make({
-          name: stack.name,
-          providers: Layer.effectContext(Effect.context<never>()),
-          state: State.localState(),
-          stack: {
-            ...stack,
-            resources: {},
-            bindings: {},
-            output: {},
-          },
-        }),
-        Effect.flatMap(Plan.make),
-        Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),
-        Effect.flatMap(apply),
-        provideFreshArtifactStore,
-      ),
-    );
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: TestOptions,
+  ) => void;
 }
 
-type AnyAction = Plan.CRUD["action"] | Plan.BindingAction | DerivedAction;
+interface BeforeAllFn {
+  <A>(eff: TestEffect<A>, options?: TestOptions): Effect.Effect<A>;
+}
 
-const formatPlan = (plan: Plan.Plan) => {
-  const items = [
-    ...Object.values(plan.resources),
-    ...Object.values(plan.deletions),
-  ] as Plan.CRUD[];
+interface BeforeEachFn {
+  (eff: TestEffect<void>, options?: TestOptions): void;
+}
 
-  if (items.length === 0) {
-    return "Plan: no changes planned";
-  }
+interface AfterAllFn {
+  (eff: TestEffect<any>, options?: TestOptions): void;
+  skipIf: (
+    predicate: boolean,
+  ) => (eff: TestEffect<any>, options?: TestOptions) => void;
+}
 
-  const counts = items.reduce(
-    (acc, item) => {
-      acc[item.action] += 1;
-      return acc;
-    },
-    {
-      create: 0,
-      update: 0,
-      delete: 0,
-      noop: 0,
-      replace: 0,
-    },
-  );
+interface AfterEachFn {
+  (eff: TestEffect<void>, options?: TestOptions): void;
+}
 
-  const summary = (["create", "update", "delete", "replace"] as const)
-    .filter((action) => counts[action] > 0)
-    .map((action) => `${counts[action]} to ${action}`)
-    .join(" | ");
+export interface TestApi {
+  test: TestFn;
+  beforeAll: BeforeAllFn;
+  beforeEach: BeforeEachFn;
+  afterAll: AfterAllFn;
+  afterEach: AfterEachFn;
+  deploy: <A>(
+    stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>,
+    options?: { stage?: string },
+  ) => ReturnType<typeof Core.deploy<A>>;
+  destroy: (
+    stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
+    options?: { stage?: string },
+  ) => ReturnType<typeof Core.destroy>;
+}
 
-  const flatItems = flattenTree(buildNamespaceTree(items));
-  const lines = [`Plan: ${summary}`];
+const DEFAULT_TIMEOUT = 120_000;
 
-  for (const item of flatItems) {
-    const indent = "  ".repeat(item.depth);
-    const icon = getActionIcon(item.action);
+/**
+ * Build the per-file test API. See {@link "./Bun.ts"} for the same shape
+ * over `bun:test`. Vitest variant uses `@effect/vitest`'s `it.live` so
+ * Effect-aware tests stay first-class.
+ */
+export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
+  const wrap = <A>(eff: TestEffect<A>) => Core.toEffect(eff, options);
+  const runEff = <A>(eff: TestEffect<A>) => Core.run(eff, options);
 
-    if (item.type === "namespace") {
-      lines.push(`${indent}${icon} ${item.id}`);
-      continue;
-    }
+  const test = ((name, eff, opts) => {
+    it.live(name, () => wrap(eff), timeoutOf(opts));
+  }) as TestFn;
 
-    if (item.type === "binding") {
-      lines.push(`${indent}${icon} ${item.bindingSid}`);
-      continue;
+  test.skip = (name, _eff, opts) => {
+    it.skip(name, () => {}, timeoutOf(opts));
+  };
+  test.skipIf = (condition) => (name, eff, opts) => {
+    if (condition) {
+      it.skip(name, () => {}, timeoutOf(opts));
+    } else {
+      it.live(name, () => wrap(eff), timeoutOf(opts));
     }
+  };
+  test.only = (name, eff, opts) => {
+    it.only(name, () => wrap(eff) as Effect.Effect<any>, timeoutOf(opts));
+  };
+  test.todo = (name, _eff, _opts) => {
+    it.todo(name);
+  };
 
-    const bindingSuffix =
-      item.bindingCount && item.bindingCount > 0
-        ? ` (${item.bindingCount} bindings)`
-        : "";
-    lines.push(
-      `${indent}${icon} ${item.id} (${item.resourceType})${bindingSuffix}`,
+  const wrapProvider = (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+  ) => {
+    const scratch = Core.scratchStack(options, name);
+    return Core.toEffect(
+      Core.withProviders(fn(scratch), options, scratch.name),
+      { ...options, state: scratch.state },
     );
-  }
-
-  return lines.join("\n");
-};
-
-const getActionIcon = (action: AnyAction): string =>
-  ({
-    create: "+",
-    update: "~",
-    delete: "-",
-    noop: "•",
-    replace: "!",
-    mixed: "*",
-  })[action] ?? "?";
-
-export function skip(
-  name: string,
-  options: {
-    timeout?: number;
-    state?: Layer.Layer<State.State, never, Stack.Stack>;
-    providers?: boolean;
-  },
-  testCase: Effect.Effect<void, any, Provided>,
-): void;
-
-export function skip(
-  name: string,
-  testCase: Effect.Effect<void, any, Provided>,
-): void;
-
-export function skip(
-  name: string,
-  ...args:
-    | [
-        {
-          timeout?: number;
-          state?: Layer.Layer<State.State, never, Stack.Stack>;
-          providers?: boolean;
-        },
-        Effect.Effect<void, any, Provided>,
-      ]
-    | [Effect.Effect<void, any, Provided>]
-) {
-  const [options = {}, _testCase] =
-    args.length === 1 ? [undefined, args[0]] : args;
-  it.skip(name, () => {}, options.timeout);
-}
+  };
 
-export function skipIf(condition: boolean) {
-  return function (
-    name: string,
-    ...args:
-      | [
-          {
-            timeout?: number;
-            state?: Layer.Layer<State.State, never, Stack.Stack>;
-            providers?: boolean;
-          },
-          Effect.Effect<void, any, Provided>,
-        ]
-      | [Effect.Effect<void, any, Provided>]
-  ) {
+  const provider = ((name, fn, opts) => {
+    it.live(name, () => wrapProvider(name, fn), timeoutOf(opts));
+  }) as ProviderFn;
+  provider.skip = (name, _fn, opts) => {
+    it.skip(name, () => {}, timeoutOf(opts));
+  };
+  provider.skipIf = (condition) => (name, fn, opts) => {
     if (condition) {
-      const [options = {}, _testCase] =
-        args.length === 1 ? [undefined, args[0]] : args;
-      it.skip(name, () => {}, options.timeout);
+      it.skip(name, () => {}, timeoutOf(opts));
     } else {
-      test(name, ...(args as [Effect.Effect<void, any, Provided>]));
+      it.live(name, () => wrapProvider(name, fn), timeoutOf(opts));
     }
   };
-}
+  test.provider = provider;
+
+  const beforeAll: BeforeAllFn = <A>(
+    eff: TestEffect<A>,
+    hookOptions?: TestOptions,
+  ) => {
+    let result: A;
+    vitestBeforeAll(
+      () => runEff(eff).then((v) => (result = v)),
+      timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
+    );
+    return Effect.sync(() => result);
+  };
 
-export function beforeAll<A, E = never, R extends Provided = never>(
-  effect: Effect.Effect<A, E, R>,
-  options?: { timeout?: number; stackName?: string },
-): void {
-  const testPath = expect.getState().testPath ?? "";
-  const stackName = options?.stackName ?? deriveStackName(testPath, "suite");
+  const beforeEach: BeforeEachFn = (eff, hookOptions) => {
+    vitestBeforeEach(() => runEff(eff), timeoutOf(hookOptions));
+  };
 
-  vitestBeforeAll(
-    () => Effect.runPromise(Effect.scoped(runWithContext(stackName, effect))),
-    options?.timeout,
-  );
-}
+  const afterAll = ((eff, hookOptions) => {
+    vitestAfterAll(
+      () => runEff(eff),
+      timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
+    );
+  }) as AfterAllFn;
+  afterAll.skipIf = (predicate) => (eff, hookOptions) => {
+    if (predicate) return;
+    vitestAfterAll(
+      () => runEff(eff),
+      timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
+    );
+  };
 
-export function afterAll<A, E, R extends Provided = never>(
-  effect: Effect.Effect<A, E, R>,
-  options?: { timeout?: number; stackName?: string },
-): void {
-  const testPath = expect.getState().testPath ?? "";
-  const stackName = options?.stackName ?? deriveStackName(testPath, "suite");
+  const afterEach: AfterEachFn = (eff, hookOptions) => {
+    vitestAfterEach(() => runEff(eff), timeoutOf(hookOptions));
+  };
 
-  vitestAfterAll(
-    () => Effect.runPromise(Effect.scoped(runWithContext(stackName, effect))),
-    options?.timeout,
-  );
-}
-export const destroy = () =>
-  Stack.Stack.use((stack) =>
-    Plan.make({
-      name: stack.name,
-      stage: stack.stage,
-      resources: {},
-      bindings: {},
-      output: {},
-    }).pipe(Effect.flatMap(apply), provideFreshArtifactStore),
-  );
+  return {
+    test,
+    beforeAll,
+    beforeEach,
+    afterAll,
+    afterEach,
+    deploy: (stack, callOpts) => Core.deploy(options, stack, callOpts),
+    destroy: (stack, callOpts) => Core.destroy(options, stack, callOpts),
+  };
+};