@shivaedev/test-story 0.0.0 → 0.1.1

package/src/internal/storyIt.ts

@@ -0,0 +1,68 @@
+import type { TestContext } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import type { EffectTest, EffectTestOptions } from "@shivaedev/effect-test/types.ts";
+import { makeEffectIt } from "@shivaedev/effect-test/vitest.ts";
+import { type Genre, genreOf } from "#internal/genre.ts";
+import { type AnyEffect, hooked } from "#internal/hooked.ts";
+import type { LooseDefinition, LooseTrait } from "#internal/seed.ts";
+import { start } from "#internal/start.ts";
+
+type LooseBody = (told: object, context: TestContext) => Generator<AnyEffect, unknown, never> | undefined;
+
+type LooseTest = (name: string, given: readonly LooseTrait[], body?: LooseBody, options?: number | EffectTestOptions) => void;
+
+export interface LooseIt extends LooseTest {
+	readonly fails: LooseTest;
+	readonly only: LooseTest;
+	readonly runIf: (condition: unknown) => LooseTest;
+	readonly skip: LooseTest;
+	readonly skipIf: (condition: unknown) => LooseTest;
+}
+
+function withTags(options: number | EffectTestOptions | undefined, tags: readonly string[]): EffectTestOptions {
+	if (typeof options === "number") {
+		return { tags: [...tags], timeout: options };
+	}
+	const own = options?.tags ?? [];
+	return { ...options, tags: [...tags, ...(typeof own === "string" ? [own] : own)] };
+}
+
+function storyOf(definition: LooseDefinition, given: readonly LooseTrait[], body: LooseBody | undefined) {
+	return function* story(_harness: unknown, context: TestContext) {
+		const told = yield* start(definition, given, context);
+		return yield* hooked(() => body?.(told, context));
+	};
+}
+
+// Vitest refuses a tag its config does not declare, so a genre the config leaves out names the test without tagging it.
+function declaring(definition: LooseDefinition, genre: Genre, declare: EffectTest<unknown, unknown>): LooseTest {
+	return (name, given, body, options) => {
+		const title = `${genre.title}: ${name}`;
+		const story = storyOf(definition, given, body);
+		try {
+			declare(title, story, withTags(options, [genre.tag.name]));
+		} catch (error) {
+			if (!(error instanceof Error && error.message.includes(`"${genre.tag.name}"`))) {
+				throw error;
+			}
+			declare(title, story, withTags(options, []));
+		}
+	};
+}
+
+export function storyIt(definition: LooseDefinition): LooseIt {
+	const genre = genreOf(definition.name);
+	const { effectApp } = makeEffectIt({
+		around: definition.around,
+		clock: definition.clock,
+		layer: definition.layer ?? Layer.empty,
+		makeHarness: () => Effect.void,
+	});
+	return Object.assign(declaring(definition, genre, effectApp), {
+		fails: declaring(definition, genre, effectApp.fails),
+		only: declaring(definition, genre, effectApp.only),
+		runIf: (condition: unknown) => declaring(definition, genre, effectApp.runIf(condition)),
+		skip: declaring(definition, genre, effectApp.skip),
+		skipIf: (condition: unknown) => declaring(definition, genre, effectApp.skipIf(condition)),
+	});
+}

package/src/internal/traits.ts

@@ -0,0 +1,20 @@
+import { callSite } from "#internal/callSite.ts";
+
+export interface TraitPart<TStage extends string, TApply> {
+	readonly apply: TApply;
+	readonly line: string;
+	readonly site: Error;
+	readonly stage: TStage;
+}
+
+export interface Parts<TStage extends string, TApply> {
+	readonly parts: readonly TraitPart<TStage, TApply>[];
+}
+
+export function trait<TStage extends string, TApply>(stage: TStage, line: string, apply: TApply): Parts<TStage, TApply> {
+	return { parts: [{ apply, line, site: callSite(), stage }] };
+}
+
+export function traits<TStage extends string, TApply>(...given: readonly Parts<TStage, TApply>[]): Parts<TStage, TApply> {
+	return { parts: given.flatMap((each) => each.parts) };
+}

package/src/internal/wrap.ts

@@ -0,0 +1,50 @@
+export const WIDTH = 120;
+
+export function wrap(text: string, { first = "", rest = "" }: { readonly first?: string; readonly rest?: string } = {}): string[] {
+	const lines: string[] = [];
+	let line = first;
+	for (const word of text.split(" ")) {
+		const prefix = lines.length === 0 ? first : rest;
+		if (line.length > prefix.length && line.length + 1 + word.length > WIDTH) {
+			lines.push(line);
+			line = `${rest}${word}`;
+		} else {
+			line = line.length > prefix.length ? `${line} ${word}` : `${line}${word}`;
+		}
+	}
+	return [...lines, line];
+}
+
+export function explained(what: string, help: string): string {
+	return [...wrap(what, { rest: "  " }), ...wrap(help, { first: "help: ", rest: "      " })].join("\n");
+}
+
+function members(json: string): string[] {
+	const value: unknown = JSON.parse(json);
+	if (Array.isArray(value)) {
+		return value.map((item) => JSON.stringify(item));
+	}
+	return typeof value === "object" && value !== null
+		? Object.entries(value).map(([key, item]) => `${JSON.stringify(key)}:${JSON.stringify(item)}`)
+		: [json];
+}
+
+export function wrapJson(json: string): string[] {
+	const [open, close] = json.startsWith("[") ? ["[", "]"] : ["{", "}"];
+	const pieces = members(json);
+	if (pieces.length < 2) {
+		return [json];
+	}
+	const lines: string[] = [];
+	let line = open;
+	for (const [index, piece] of pieces.entries()) {
+		const next = `${piece}${index === pieces.length - 1 ? close : ","}`;
+		if (line.length > 1 && line.length + next.length > WIDTH) {
+			lines.push(line);
+			line = next;
+		} else {
+			line += next;
+		}
+	}
+	return [...lines, line];
+}

package/src/storyKit.ts

@@ -0,0 +1,130 @@
+import type { TestContext } from "@effect/vitest";
+import type { Effect, Layer, Scope } from "effect";
+import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test/types.ts";
+import { type AnyEffect, type ErrorOf, type Hook, hooked, type ServicesOf } from "#internal/hooked.ts";
+import type { LooseDefinition, LooseTrait } from "#internal/seed.ts";
+import { type LooseIt, storyIt } from "#internal/storyIt.ts";
+import { type Parts, trait, traits } from "#internal/traits.ts";
+
+export type Trait<TEngine, TStage extends string, R = never> = Parts<TStage, (engine: TEngine) => Effect.Effect<void, unknown, R>>;
+
+type TraitServices<TTrait> = TTrait extends Parts<string, (engine: never) => Effect.Effect<void, unknown, infer R>> ? R : never;
+
+type Needs<TProvided> = Effect.Effect<unknown, unknown, TProvided>;
+
+// A plain after hook yields nothing to infer, so TypeScript leaves its effect at the AnyEffect constraint.
+type AfterEffects<TAfter> = { readonly [TKey in keyof TAfter]-?: AnyEffect extends TAfter[TKey] ? never : TAfter[TKey] }[keyof TAfter];
+
+type LayerFor<THooks, TProvided> = [Exclude<ServicesOf<THooks>, Scope.Scope>] extends [TProvided]
+	? unknown
+	: { readonly layer: Layer.Layer<Exclude<ServicesOf<THooks>, Scope.Scope>, unknown, never> };
+
+export interface RunUntilOptions {
+	readonly maxSteps?: number | undefined;
+}
+
+export interface Story<TEngine, TRun extends AnyEffect = never> {
+	readonly engine: TEngine;
+	readonly lines: readonly string[];
+	readonly runUntil: <TUntil extends AnyEffect = never>(
+		until: Hook<[engine: TEngine], TUntil, boolean>,
+		options?: RunUntilOptions,
+	) => Effect.Effect<void, ErrorOf<TRun | TUntil>, ServicesOf<TRun | TUntil>>;
+	readonly tell: (line: string) => void;
+}
+
+export interface RunHooks<TEngine, TStep extends AnyEffect, TFailed extends AnyEffect, TDiagnose extends AnyEffect> {
+	readonly diagnose?: Hook<[engine: TEngine], TDiagnose, string>;
+	readonly failed?: Hook<[engine: TEngine], TFailed, string | undefined>;
+	readonly maxSteps: number;
+	readonly step: Hook<[engine: TEngine, tell: (line: string) => void], TStep, void>;
+}
+
+export interface StoryKitDefinition<
+	TEngine,
+	TStage extends string,
+	TVerbs,
+	TProvided,
+	TCreate extends AnyEffect,
+	TAfter extends { readonly [TKey in TStage]?: AnyEffect },
+	TStep extends AnyEffect,
+	TFailed extends AnyEffect,
+	TDiagnose extends AnyEffect,
+> {
+	readonly after?: { readonly [TKey in keyof TAfter]: Hook<[engine: TEngine], TAfter[TKey] & AnyEffect, void> };
+	readonly around?: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, unknown, R | NoInfer<TProvided> | Scope.Scope>;
+	readonly clock?: EffectClock;
+	readonly create: Hook<[], TCreate, TEngine>;
+	readonly inspect?: (engine: TEngine) => unknown;
+	readonly layer?: Layer.Layer<TProvided, unknown, never>;
+	readonly name: string;
+	readonly run?: RunHooks<TEngine, TStep, TFailed, TDiagnose>;
+	readonly stages: readonly [TStage, ...TStage[]];
+	readonly verbs: (engine: TEngine, story: Story<TEngine, TStep | TFailed | TDiagnose>) => TVerbs;
+}
+
+export type Told<TEngine, TVerbs, TRun extends AnyEffect> = TVerbs & { readonly story: Story<TEngine, TRun> };
+
+export type StoryBody<TEngine, TVerbs, TRun extends AnyEffect, TEffect extends AnyEffect> = (
+	told: Told<TEngine, TVerbs, TRun>,
+	context: TestContext,
+) => Generator<TEffect, unknown, never> | undefined;
+
+export type StoryTest<TEngine, TStage extends string, TVerbs, TRun extends AnyEffect, TProvided> = <
+	TEffect extends Needs<TProvided | Scope.Scope> = never,
+>(
+	name: string,
+	given: readonly Trait<TEngine, TStage, TProvided | Scope.Scope>[],
+	body?: StoryBody<TEngine, TVerbs, TRun, TEffect>,
+	options?: number | EffectTestOptions,
+) => void;
+
+export interface StoryIt<TEngine, TStage extends string, TVerbs, TRun extends AnyEffect, TProvided>
+	extends StoryTest<TEngine, TStage, TVerbs, TRun, TProvided> {
+	readonly fails: StoryTest<TEngine, TStage, TVerbs, TRun, TProvided>;
+	readonly only: StoryTest<TEngine, TStage, TVerbs, TRun, TProvided>;
+	readonly runIf: (condition: unknown) => StoryTest<TEngine, TStage, TVerbs, TRun, TProvided>;
+	readonly skip: StoryTest<TEngine, TStage, TVerbs, TRun, TProvided>;
+	readonly skipIf: (condition: unknown) => StoryTest<TEngine, TStage, TVerbs, TRun, TProvided>;
+}
+
+export interface StoryKit<TEngine, TStage extends string, TVerbs, TRun extends AnyEffect, TProvided> {
+	readonly it: StoryIt<TEngine, TStage, TVerbs, TRun, TProvided>;
+	readonly trait: <TEffect extends AnyEffect = never>(
+		stage: TStage,
+		line: string,
+		apply: Hook<[engine: TEngine], TEffect, void>,
+	) => Trait<TEngine, TStage, ServicesOf<TEffect>>;
+	readonly traits: <const TGiven extends readonly Trait<TEngine, TStage, unknown>[]>(
+		...given: TGiven
+	) => Trait<TEngine, TStage, TraitServices<TGiven[number]>>;
+}
+
+interface LooseKit {
+	readonly it: LooseIt;
+	readonly trait: (stage: string, line: string, apply: Hook<[engine: unknown], AnyEffect, void>) => LooseTrait;
+	readonly traits: (...given: readonly LooseTrait[]) => LooseTrait;
+}
+
+// The implementation works on loose types; the overload states what the definition infers.
+export function storyKit<
+	TEngine,
+	const TStage extends string,
+	TVerbs extends object,
+	TProvided = never,
+	TCreate extends AnyEffect = never,
+	TAfter extends { readonly [TKey in TStage]?: AnyEffect } = Record<never, never>,
+	TStep extends AnyEffect = never,
+	TFailed extends AnyEffect = never,
+	TDiagnose extends AnyEffect = never,
+>(
+	definition: StoryKitDefinition<TEngine, TStage, TVerbs, TProvided, TCreate, TAfter, TStep, TFailed, TDiagnose> &
+		LayerFor<TCreate | AfterEffects<TAfter> | TStep | TFailed | TDiagnose, TProvided>,
+): StoryKit<TEngine, TStage, TVerbs, TStep | TFailed | TDiagnose, TProvided>;
+export function storyKit(definition: LooseDefinition): LooseKit {
+	return {
+		it: storyIt(definition),
+		trait: (stage, line, apply) => trait(stage, line, (engine) => hooked(() => apply(engine))),
+		traits,
+	};
+}

package/login.log

@@ -1,26 +0,0 @@
-
-https://www.npmjs.com/login?next=/login/cli/d0180614-d018-4dd0-9303-d9e68a5ed5a0
-
-▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
-█ ▄▄▄▄▄ █   █▄███▀█▄▀██▄▄ ▀█▄██ ▄▄▄▄▄ █
-█ █   █ █ ▀▄ █▄▀  ▄█▀▄▄▀▀ ▀▄ ██ █   █ █
-█ █▄▄▄█ █▀██▀▀  ▀▄▄▀▀▄█ ▄ █▄▄▄█ █▄▄▄█ █
-█▄▄▄▄▄▄▄█▄▀▄█ █ █▄▀ ▀▄▀ ▀▄█ ▀ █▄▄▄▄▄▄▄█
-█ ▄▀▀▄▄▄██▀▀▄▀▄▄▄▄▄▀▄▀ █▀▀█▀  ██▄▀▄  ▄█
-██ ▄ ▄ ▄█▄▀▀ ▄ ▄ ▀  ██ █ ██▄ █▄▀▀  ▀▄▀█
-█ █▄▀ ▀▄█▄ ▄█▄ ▀█▀▄▄▄▀▄▄ ▀█▀▀▀▄▄ ▀▀ ▀▄█
-█▄█▀█▀▄▄▀ █▄█▀█▀█▄▀▄▀▄ ▀ ▄▄ ▄▄█ ▄▄▀▀▀██
-█ █▄█▀▀▄ ▄▀▀▄▀▄▄▄▄ ▄▄▀▄▀▀▀▀▀ ▀▄▄█▀▀ ▀▄█
-█▀ ▄▄ ▄▄█▄▀█ ▄ ▄ ▀ ██▄   █▄ ▄██▄█ █▀▀██
-█ ██▀▄▄▄██▀ █▄ ▀█▀▄▀█▀▄▀▀▀█▀ ▄█▄▄▀ ▄ ▄█
-██ ▀█ ▄▄ ██▄█▀█▀█▄ ▀█  ▄ ▀█▀▄▄█  ▀█▀▀██
-█ ▄  ▀ ▄█▄█ ▄▀▄▄▄█▄▄█  ▀▀▄█▀ ▀▄▄▄▀ ▄ ▄█
-███▀ ▀ ▄▀▄   ▄ ▄    ██  ▄ ▄▄ ▀▀▄███▀▀██
-█▄▄▄▄▄▄▄█ ▄██▄ ▀▀▄▄▀▄▀ █  █ ▄ ▄▄▄  ▄███
-█ ▄▄▄▄▄ █▀▀▄█▀█▀ ▀  █▀ █ ▄▄ █ █▄█ ▀▀▀██
-█ █   █ █▄ █▄▀▄▄▀▀▄▀▄▄▄▀ ▄▀▀▀   ▄▄▀ ▀ █
-█ █▄▄▄█ █▀   ▄ ▄ █ ▄█▀ ▀ ▀▄▀▀▄▄ ▄▀▄▀▀██
-█▄▄▄▄▄▄▄█▄▄▄█▄▄██▄▄▄▄▄▄▄▄▄██▄█▄████▄▄▄█
-
-Press ENTER to open the URL in your browser.
-Logged in on https://registry.npmjs.org/

package/run.out

@@ -1,26 +0,0 @@
-
-https://www.npmjs.com/login?next=/login/cli/d0180614-d018-4dd0-9303-d9e68a5ed5a0
-
-▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
-█ ▄▄▄▄▄ █   █▄███▀█▄▀██▄▄ ▀█▄██ ▄▄▄▄▄ █
-█ █   █ █ ▀▄ █▄▀  ▄█▀▄▄▀▀ ▀▄ ██ █   █ █
-█ █▄▄▄█ █▀██▀▀  ▀▄▄▀▀▄█ ▄ █▄▄▄█ █▄▄▄█ █
-█▄▄▄▄▄▄▄█▄▀▄█ █ █▄▀ ▀▄▀ ▀▄█ ▀ █▄▄▄▄▄▄▄█
-█ ▄▀▀▄▄▄██▀▀▄▀▄▄▄▄▄▀▄▀ █▀▀█▀  ██▄▀▄  ▄█
-██ ▄ ▄ ▄█▄▀▀ ▄ ▄ ▀  ██ █ ██▄ █▄▀▀  ▀▄▀█
-█ █▄▀ ▀▄█▄ ▄█▄ ▀█▀▄▄▄▀▄▄ ▀█▀▀▀▄▄ ▀▀ ▀▄█
-█▄█▀█▀▄▄▀ █▄█▀█▀█▄▀▄▀▄ ▀ ▄▄ ▄▄█ ▄▄▀▀▀██
-█ █▄█▀▀▄ ▄▀▀▄▀▄▄▄▄ ▄▄▀▄▀▀▀▀▀ ▀▄▄█▀▀ ▀▄█
-█▀ ▄▄ ▄▄█▄▀█ ▄ ▄ ▀ ██▄   █▄ ▄██▄█ █▀▀██
-█ ██▀▄▄▄██▀ █▄ ▀█▀▄▀█▀▄▀▀▀█▀ ▄█▄▄▀ ▄ ▄█
-██ ▀█ ▄▄ ██▄█▀█▀█▄ ▀█  ▄ ▀█▀▄▄█  ▀█▀▀██
-█ ▄  ▀ ▄█▄█ ▄▀▄▄▄█▄▄█  ▀▀▄█▀ ▀▄▄▄▀ ▄ ▄█
-███▀ ▀ ▄▀▄   ▄ ▄    ██  ▄ ▄▄ ▀▀▄███▀▀██
-█▄▄▄▄▄▄▄█ ▄██▄ ▀▀▄▄▀▄▀ █  █ ▄ ▄▄▄  ▄███
-█ ▄▄▄▄▄ █▀▀▄█▀█▀ ▀  █▀ █ ▄▄ █ █▄█ ▀▀▀██
-█ █   █ █▄ █▄▀▄▄▀▀▄▀▄▄▄▀ ▄▀▀▀   ▄▄▀ ▀ █
-█ █▄▄▄█ █▀   ▄ ▄ █ ▄█▀ ▀ ▀▄▀▀▄▄ ▄▀▄▀▀██
-█▄▄▄▄▄▄▄█▄▄▄█▄▄██▄▄▄▄▄▄▄▄▄██▄█▄████▄▄▄█
-
-Press ENTER to open the URL in your browser.
-Logged in on https://registry.npmjs.org/

package/run.sh

@@ -1,10 +0,0 @@
-#!/bin/zsh
-cd "${0:A:h}"
-watch_open() { local log=$1 pat=$2; ( for i in {1..600}; do u=$(tr -d '\r' < "$log" 2>/dev/null | grep -oE "$pat" | tail -1); if [[ -n $u ]]; then open -g "$u"; break; fi; sleep 1; done ) & }
-: > login.log; watch_open login.log 'https://www\.npmjs\.com/login\?next=[A-Za-z0-9/=?._-]+'
-sleep 300 | script -q -F login.log pnpm login
-: > publish.log; watch_open publish.log 'https://www\.npmjs\.com/auth/cli/[A-Za-z0-9/=?._-]+'
-sleep 300 | script -q -F publish.log pnpm publish --access public --no-git-checks
-echo "publish exit $?"
-pnpm logout
-npm view @shivaedev/test-story versions