import * as AWS from "@alchemy.run/aws";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as neptunegraph from "@distilled.cloud/aws/neptune-graph";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as Schedule from "effect/Schedule";
import NeptuneGraphTestFunctionLive, { FixtureGraph, NeptuneGraphTestFunction } from "./handler.ts";
const { test } = Test.make({ providers: AWS.providers() });
// Ungated typed-error probe: proves the distilled error union carries the
// not-found tag this provider's read/delete/wait paths depend on. Runs in
// every CI pass at near-zero cost, unlike the gated lifecycle below.
test.provider(
"getGraph on a nonexistent graph fails with ResourceNotFoundException",
() =>
Effect.gen(function* () {
const error = yield* Effect.flip(
// Well-formed but nonexistent graph id (g-<10 alphanumerics>).
neptunegraph.getGraph({ graphIdentifier: "g-0123456789" }),
);
expect(error._tag).toBe("ResourceNotFoundException");
}),
{ tags: ["provider:aws", "provider:aws:neptunegraph", "live"] },
);
// The snapshot / import-task / export-task bindings address resources by
// server-generated ids that only exist at runtime — probe their typed
// not-found tags so the account-level grants and error unions stay proven
// without provisioning a graph.
test.provider(
"getGraphSnapshot on a nonexistent snapshot fails with ResourceNotFoundException",
() =>
Effect.gen(function* () {
const error = yield* Effect.flip(
// Well-formed but nonexistent snapshot id (gs-<10 alphanumerics>).
neptunegraph.getGraphSnapshot({ snapshotIdentifier: "gs-0123456789" }),
);
expect(error._tag).toBe("ResourceNotFoundException");
}),
{ tags: ["provider:aws", "provider:aws:neptunegraph", "live"] },
);
test.provider(
"getImportTask on a nonexistent task fails with ResourceNotFoundException",
() =>
Effect.gen(function* () {
const error = yield* Effect.flip(
neptunegraph.getImportTask({ taskIdentifier: "t-0123456789" }),
);
expect(error._tag).toBe("ResourceNotFoundException");
}),
{ tags: ["provider:aws", "provider:aws:neptunegraph", "live"] },
);
test.provider(
"getExportTask on a nonexistent task fails with ResourceNotFoundException",
() =>
Effect.gen(function* () {
const error = yield* Effect.flip(
neptunegraph.getExportTask({ taskIdentifier: "t-0123456789" }),
);
expect(error._tag).toBe("ResourceNotFoundException");
}),
{ tags: ["provider:aws", "provider:aws:neptunegraph", "live"] },
);
const assertGraphGone = (graphId: string) =>
neptunegraph.getGraph({ graphIdentifier: graphId }).pipe(
Effect.flatMap((graph) =>
Effect.fail(new Error(`graph '${graphId}' still exists (status: ${graph.status})`)),
),
Effect.catchTag("ResourceNotFoundException", () => Effect.void),
Effect.retry({ schedule: Schedule.max([Schedule.fixed("10 seconds"), Schedule.recurs(30)]) }),
);
// A Neptune Analytics graph takes ~5-10 minutes to provision and bills per
// m-NCU-hour (16 m-NCUs here) while it exists. The full lifecycle — graph +
// Lambda running openCypher through the ExecuteQuery binding — is skipped
// under `--fast` and always destroys what it created.
test.provider.skipIf(!!process.env.FAST)(
"create graph, query it from Lambda via ExecuteQuery, destroy",
(stack) =>
Effect.gen(function* () {
// Clean slate in case a previous run died mid-flight.
yield* stack.destroy();
const { graph, fn } = yield* stack.deploy(
Effect.gen(function* () {
const { graph } = yield* FixtureGraph;
const fn = yield* NeptuneGraphTestFunction;
return { graph, fn };
}).pipe(Effect.provide(NeptuneGraphTestFunctionLive)),
);
expect(graph.graphId).toMatch(/^g-/);
expect(graph.graphArn).toContain(":graph/");
expect(graph.status).toBe("AVAILABLE");
expect(graph.provisionedMemory).toBe(16);
expect(graph.publicConnectivity).toBe(true);
expect(graph.replicaCount).toBe(0);
expect(graph.deletionProtection).toBe(false);
expect(graph.endpoint).toContain("neptune-graph");
// Out-of-band verification via distilled.
const observed = yield* neptunegraph.getGraph({ graphIdentifier: graph.graphId });
expect(observed.status).toBe("AVAILABLE");
expect(observed.name).toBe(graph.graphName);
// Drive the deployed Lambda. First request rides URL propagation —
// bounded retry.
const baseUrl = fn.functionUrl!.replace(/\/+$/, "");
const graphInfo = yield* HttpClient.get(`${baseUrl}/graph`).pipe(
Effect.flatMap((res) =>
res.status === 200 ? res.json : Effect.fail(new Error(`/graph returned ${res.status}`)),
),
Effect.retry({
schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(40)]),
}),
);
expect((graphInfo as { graphId: string }).graphId).toBe(graph.graphId);
// openCypher through the ExecuteQuery binding: write a node, read it
// back.
const query = (body: { query: string; parameters?: Record<string, unknown> }) =>
HttpClient.execute(
HttpClientRequest.post(`${baseUrl}/query`).pipe(HttpClientRequest.bodyJsonUnsafe(body)),
).pipe(
Effect.flatMap((res) =>
res.status === 200
? res.json
: res.text.pipe(
Effect.flatMap((text) =>
Effect.fail(new Error(`/query returned ${res.status}: ${text}`)),
),
),
),
Effect.retry({
schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(10)]),
}),
);
yield* query({ query: "CREATE (n:Person {name: $name})", parameters: { name: "Ada" } });
const read = (yield* query({ query: "MATCH (n:Person) RETURN n.name AS name" })) as {
results: Array<{ name: string }>;
};
expect(read.results).toEqual([{ name: "Ada" }]);
const getJson = (path: string) =>
HttpClient.get(`${baseUrl}${path}`).pipe(
Effect.flatMap((res) =>
res.status === 200
? res.json
: res.text.pipe(
Effect.flatMap((text) =>
Effect.fail(new Error(`${path} returned ${res.status}: ${text}`)),
),
),
),
Effect.retry({
schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(10)]),
}),
);
// GetGraphSummary binding: the summary document reflects the graph.
const summary = (yield* getJson("/summary")) as { graphSummary?: { numNodes?: number } };
expect(summary.graphSummary).toBeDefined();
// ListQueries binding: returns a well-formed (usually empty) list.
const queries = (yield* getJson("/queries")) as { queries: unknown[] };
expect(Array.isArray(queries.queries)).toBe(true);
// ListGraphSnapshots binding: fresh graph has no snapshots.
const snapshots = (yield* getJson("/snapshots")) as { graphSnapshots: unknown[] };
expect(Array.isArray(snapshots.graphSnapshots)).toBe(true);
// Destroy immediately — the graph bills while it exists — and verify
// it is fully gone out-of-band.
yield* stack.destroy();
yield* assertGraphGone(graph.graphId);
}),
// graph create (~5-10 min) + lambda deploy + delete-until-gone, one test.
{
tags: ["provider:aws", "provider:aws:lambda", "provider:aws:neptunegraph", "live"],
timeout: 1_500_000,
},
);