@shivaedev/test-story 0.4.0 → 0.5.0

package/src/server/internal/storyIt.ts

@@ -30,8 +30,7 @@ function withTags(options: number | EffectTestOptions | undefined, tags: readonl
 
 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));
+		return yield* start(definition, given, context, (told) => hooked(() => body?.(told, context)));
 	};
 }
 
@@ -67,11 +66,14 @@ export function storyIt(definition: LooseDefinition): LooseIt {
 		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)),
+	function register(declare: EffectTest<unknown, unknown>) {
+		return declaring(definition, genre, definition.runIf === false ? effectApp.skip : declare);
+	}
+	return Object.assign(register(effectApp), {
+		fails: register(effectApp.fails),
+		only: register(effectApp.only),
+		runIf: (condition: unknown) => register(effectApp.runIf(condition)),
+		skip: register(effectApp.skip),
+		skipIf: (condition: unknown) => register(effectApp.skipIf(condition)),
 	});
 }

package/src/server/otlpReceiver.ts

@@ -0,0 +1,69 @@
+import { createServer, type IncomingHttpHeaders, type IncomingMessage, type ServerResponse } from "node:http";
+import { Effect } from "effect";
+import { otlpReadout } from "#internal/otlpReadout.ts";
+
+export type OtlpSpan = ReturnType<typeof otlpReadout>[number];
+export interface OtlpExport {
+	readonly body: Buffer;
+	readonly headers: IncomingHttpHeaders;
+	readonly path: string | undefined;
+	readonly rawHeaders: readonly string[];
+}
+export interface OtlpReceiverOptions {
+	readonly answer?: string;
+	readonly path?: string;
+	readonly status?: number | ((attempt: number) => number);
+}
+
+async function receive(request: IncomingMessage, response: ServerResponse, requests: OtlpExport[], spans: OtlpSpan[], options: OtlpReceiverOptions) {
+	try {
+		const chunks: Buffer[] = [];
+		for await (const chunk of request) {
+			chunks.push(Buffer.from(chunk));
+		}
+		const body = Buffer.concat(chunks);
+		requests.push({ body, headers: request.headers, path: request.url, rawHeaders: request.rawHeaders });
+		if (request.method !== "POST" || request.url !== (options.path ?? "/v1/traces")) {
+			response.writeHead(404).end();
+			return;
+		}
+		const contentType = request.headers["content-type"]?.split(";")[0]?.trim();
+		if (contentType !== "application/json" && contentType !== "application/x-protobuf") {
+			response.writeHead(415).end();
+			return;
+		}
+		spans.push(...otlpReadout(body, contentType));
+		response.writeHead(typeof options.status === "function" ? options.status(requests.length) : (options.status ?? 200)).end(options.answer ?? "{}");
+	} catch {
+		response.writeHead(400).end();
+	}
+}
+
+export const otlpReceiver = Effect.fnUntraced(function* (options: OtlpReceiverOptions = {}) {
+	const requests: OtlpExport[] = [];
+	const spans: OtlpSpan[] = [];
+	const server = createServer((request, response) => receive(request, response, requests, spans, options));
+	yield* Effect.acquireRelease(
+		Effect.tryPromise(
+			() =>
+				new Promise<void>((resolve, reject) => {
+					server.once("error", reject);
+					server.listen(0, "127.0.0.1", () => {
+						server.off("error", reject);
+						resolve();
+					});
+				}),
+		),
+		() => Effect.promise(() => new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))),
+	);
+	const address = server.address();
+	if (address === null || typeof address === "string") {
+		return yield* Effect.die("Missing OTLP receiver address");
+	}
+	const receiver: { readonly requests: readonly OtlpExport[]; readonly spans: readonly OtlpSpan[]; readonly url: string } = {
+		requests,
+		spans,
+		url: `http://127.0.0.1:${address.port}`,
+	};
+	return receiver;
+});

package/src/server/storyKit.ts

@@ -54,6 +54,7 @@ export interface StoryKitDefinition<
 	readonly name: string;
 	readonly outbound?: Readonly<Record<string, string>>;
 	readonly run?: RunHooks<TEngine, TStep, TFailed, TDiagnose>;
+	readonly runIf?: boolean;
 	readonly stages: readonly [TStage, ...TStage[]];
 	readonly verbs: (engine: TEngine, story: Story<TEngine, TStep | TFailed | TDiagnose>) => TVerbs;
 }