feat(versioning): version scenarios and snippets, bump to 1.16.0
- snapshot scenario and snippet content into version tables on every
content change; live tables keep holding the latest version
- record the scenario version on each run and copy its steps into the
run steps, so runs execute and show the version they were created with
- keep run step history when a step is deleted (FK set null)
- pin a snippet version with runSnippet('alias@N')
- add version picker to the run modal and version info across the UI
- add version list/get endpoints and MCP tools
- include version in exports and require it on import, restoring the
exact version by id + version
This commit is contained in:
1 parent
9fb6e8538b
commit
eed385debf
40 files changed
+1457
-137
No files matched your search
@@ -38,6 +38,8 @@ import { SessionEntity } from "../src/session/session.entity";
|
||||
import { EnvironmentEntity } from "../src/environment/environment.entity";
|
||||
import { ScenarioEntity } from "../src/scenario/scenario.entity";
|
||||
import { ScenarioStepEntity } from "../src/scenario/scenario-step.entity";
|
||||
import { ScenarioVersionEntity } from "../src/scenario/scenario-version.entity";
|
||||
import { SnippetVersionEntity } from "../src/snippet/snippet-version.entity";
|
||||
import { ScenarioRunEntity } from "../src/scenario/scenario-run.entity";
|
||||
import { ScenarioRunStepEntity } from "../src/scenario/scenario-run-step.entity";
|
||||
import { ScenarioRunLogEntity } from "../src/scenario/scenario-run-log.entity";
|
||||
@@ -68,12 +70,14 @@ export async function buildTestApp(): Promise<INestApplication> {
|
||||
EnvironmentEntity,
|
||||
ScenarioEntity,
|
||||
ScenarioStepEntity,
|
||||
ScenarioVersionEntity,
|
||||
ScenarioRunEntity,
|
||||
ScenarioRunStepEntity,
|
||||
ScenarioRunLogEntity,
|
||||
ScenarioCredentialEntity,
|
||||
CredentialEntity,
|
||||
SnippetEntity,
|
||||
SnippetVersionEntity,
|
||||
FileEntity,
|
||||
ScenarioFileEntity,
|
||||
ScenarioRunFileEntity,
|
||||
|
||||
@@ -133,11 +133,16 @@ describe("Exec Context File Methods Integration Tests", () => {
|
||||
scenarioStepId: string,
|
||||
order = 0,
|
||||
) {
|
||||
// Run steps execute from their own copy of the step content
|
||||
const step = await stepRepo.findOneByOrFail({ id: scenarioStepId });
|
||||
const runStep = await runStepRepo.save(
|
||||
runStepRepo.create({
|
||||
runId,
|
||||
scenarioStepId,
|
||||
order,
|
||||
title: step.title,
|
||||
execCode: step.execCode,
|
||||
timeoutSeconds: step.timeoutSeconds,
|
||||
status: "pending",
|
||||
}),
|
||||
);
|
||||
|
||||
@@ -124,11 +124,16 @@ describe("McpController", () => {
|
||||
}
|
||||
|
||||
async function createRunStep(runId: string, scenarioStepId: string, order = 0) {
|
||||
// Run steps execute from their own copy of the step content
|
||||
const step = await stepRepo.findOneByOrFail({ id: scenarioStepId });
|
||||
return runStepRepo.save(
|
||||
runStepRepo.create({
|
||||
runId,
|
||||
scenarioStepId,
|
||||
order,
|
||||
title: step.title,
|
||||
execCode: step.execCode,
|
||||
timeoutSeconds: step.timeoutSeconds,
|
||||
status: "pending",
|
||||
}),
|
||||
);
|
||||
|
||||
@@ -676,6 +676,7 @@ describe("ScenarioController", () => {
|
||||
it("creates a new scenario with all steps", async () => {
|
||||
const payload = {
|
||||
name: "imported scenario",
|
||||
version: 1,
|
||||
steps: [
|
||||
{
|
||||
sessionName: "s",
|
||||
@@ -750,13 +751,20 @@ describe("ScenarioController", () => {
|
||||
it("imports with empty steps array", async () => {
|
||||
const res = await request(app.getHttpServer())
|
||||
.post("/scenarios/import")
|
||||
.send({ name: "empty-import", steps: [] })
|
||||
.send({ name: "empty-import", version: 1, steps: [] })
|
||||
.expect(201);
|
||||
|
||||
expect(res.body.name).toBe("empty-import");
|
||||
expect(res.body.steps).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("returns 400 when version is missing", async () => {
|
||||
await request(app.getHttpServer())
|
||||
.post("/scenarios/import")
|
||||
.send({ name: "no-version", steps: [] })
|
||||
.expect(400);
|
||||
});
|
||||
|
||||
it("returns 400 when name is missing", async () => {
|
||||
await request(app.getHttpServer())
|
||||
.post("/scenarios/import")
|
||||
@@ -776,6 +784,7 @@ describe("ScenarioController", () => {
|
||||
.post("/scenarios/import")
|
||||
.send({
|
||||
name: "bad-type",
|
||||
version: 1,
|
||||
steps: [{ type: "unknown", sessionName: "s" }],
|
||||
})
|
||||
.expect(201);
|
||||
|
||||
@@ -0,0 +1,393 @@
|
||||
/**
|
||||
* Integration tests for scenario and snippet versioning:
|
||||
* - versions bump on content changes only
|
||||
* - runs record and execute the scenario version they were created with
|
||||
* - runSnippet("alias@N") pins a snippet version
|
||||
* - export/import carry and restore exact versions
|
||||
*/
|
||||
|
||||
import { INestApplication } from "@nestjs/common";
|
||||
import request from "supertest";
|
||||
import { DataSource } from "typeorm";
|
||||
import { buildTestApp } from "./app.harness";
|
||||
import { CredentialEntity } from "../src/credential/credential.entity";
|
||||
import { EnvironmentEntity } from "../src/environment/environment.entity";
|
||||
import { ScenarioSchedulerService } from "../src/scenario/scenario-scheduler.service";
|
||||
import { ScenarioService } from "../src/scenario/scenario.service";
|
||||
import { SnippetService } from "../src/snippet/snippet.service";
|
||||
|
||||
describe("Versioning", () => {
|
||||
let app: INestApplication;
|
||||
let dataSource: DataSource;
|
||||
let scenarioService: ScenarioService;
|
||||
let snippetService: SnippetService;
|
||||
let scheduler: ScenarioSchedulerService;
|
||||
|
||||
beforeAll(async () => {
|
||||
app = await buildTestApp();
|
||||
dataSource = app.get(DataSource);
|
||||
scenarioService = app.get(ScenarioService);
|
||||
snippetService = app.get(SnippetService);
|
||||
scheduler = app.get(ScenarioSchedulerService);
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await app.close();
|
||||
});
|
||||
|
||||
// ── helpers ────────────────────────────────────────────────────────────────
|
||||
|
||||
const uniq = () => Math.random().toString(36).slice(2, 8);
|
||||
|
||||
async function createEnvironment(): Promise<string> {
|
||||
const repo = dataSource.getRepository(EnvironmentEntity);
|
||||
const env = await repo.save(
|
||||
repo.create({ name: `env-${uniq()}`, data: {} }),
|
||||
);
|
||||
return env.id;
|
||||
}
|
||||
|
||||
async function versionNumbers(scenarioId: string): Promise<number[]> {
|
||||
return (await scenarioService.listVersions(scenarioId)).map(
|
||||
(v) => v.version,
|
||||
);
|
||||
}
|
||||
|
||||
/** Creates and processes a run; returns it with its step runs. */
|
||||
async function runToCompletion(scenarioId: string, version?: number) {
|
||||
const run = await scenarioService.createRun(
|
||||
scenarioId,
|
||||
await createEnvironment(),
|
||||
false,
|
||||
undefined,
|
||||
version,
|
||||
);
|
||||
await scheduler.pickUpPendingRuns();
|
||||
return scenarioService.waitForRun(scenarioId, run.id, 10_000);
|
||||
}
|
||||
|
||||
const outputs = (run: { stepRuns: { output: string | null }[] }) =>
|
||||
run.stepRuns.map((s) => (s.output ? JSON.parse(s.output) : null));
|
||||
|
||||
// ── scenario versions ─────────────────────────────────────────────────────
|
||||
|
||||
describe("scenario versions", () => {
|
||||
it("starts at version 1 with a stored snapshot", async () => {
|
||||
const sc = await scenarioService.create({ name: `v-${uniq()}` });
|
||||
expect(sc.version).toBe(1);
|
||||
expect(await versionNumbers(sc.id)).toEqual([1]);
|
||||
});
|
||||
|
||||
it("bumps on scenario and step changes, not on no-op updates", async () => {
|
||||
const sc = await scenarioService.create({ name: `bump-${uniq()}` });
|
||||
await scenarioService.update(sc.id, { name: `${sc.name}-renamed` });
|
||||
expect((await scenarioService.findOne(sc.id)).version).toBe(2);
|
||||
|
||||
// Same content again: no new version
|
||||
await scenarioService.update(sc.id, { name: `${sc.name}-renamed` });
|
||||
expect((await scenarioService.findOne(sc.id)).version).toBe(2);
|
||||
|
||||
const step = await scenarioService.createStep(sc.id, {
|
||||
execCode: "return 1;",
|
||||
});
|
||||
expect((await scenarioService.findOne(sc.id)).version).toBe(3);
|
||||
await scenarioService.updateStep(sc.id, step.id, {
|
||||
execCode: "return 2;",
|
||||
});
|
||||
expect((await scenarioService.findOne(sc.id)).version).toBe(4);
|
||||
await scenarioService.removeStep(sc.id, step.id);
|
||||
expect((await scenarioService.findOne(sc.id)).version).toBe(5);
|
||||
|
||||
expect(await versionNumbers(sc.id)).toEqual([5, 4, 3, 2, 1]);
|
||||
const v4 = await scenarioService.findVersion(sc.id, 4);
|
||||
expect(v4.steps.map((s) => s.execCode)).toEqual(["return 2;"]);
|
||||
});
|
||||
|
||||
it("does not bump on credential assignment", async () => {
|
||||
const sc = await scenarioService.create({ name: `cred-${uniq()}` });
|
||||
const credRepo = dataSource.getRepository(CredentialEntity);
|
||||
const cred = await credRepo.save(
|
||||
credRepo.create({ name: "c", data: null }),
|
||||
);
|
||||
await scenarioService.addScenarioCredential(sc.id, {
|
||||
credentialId: cred.id,
|
||||
alias: "c",
|
||||
});
|
||||
expect((await scenarioService.findOne(sc.id)).version).toBe(1);
|
||||
});
|
||||
|
||||
it("exposes versions over HTTP", async () => {
|
||||
const sc = await scenarioService.create({ name: `http-${uniq()}` });
|
||||
await scenarioService.createStep(sc.id, { execCode: "return 1;" });
|
||||
|
||||
const list = await request(app.getHttpServer())
|
||||
.get(`/scenarios/${sc.id}/versions`)
|
||||
.expect(200);
|
||||
expect(list.body.map((v: { version: number }) => v.version)).toEqual([
|
||||
2, 1,
|
||||
]);
|
||||
|
||||
const one = await request(app.getHttpServer())
|
||||
.get(`/scenarios/${sc.id}/versions/2`)
|
||||
.expect(200);
|
||||
expect(one.body.steps).toHaveLength(1);
|
||||
|
||||
await request(app.getHttpServer())
|
||||
.get(`/scenarios/${sc.id}/versions/99`)
|
||||
.expect(404);
|
||||
});
|
||||
});
|
||||
|
||||
// ── runs ──────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("runs", () => {
|
||||
it("runs the latest version by default and records it", async () => {
|
||||
const sc = await scenarioService.create({ name: `run-${uniq()}` });
|
||||
await scenarioService.createStep(sc.id, { execCode: "return 'latest';" });
|
||||
|
||||
const run = await runToCompletion(sc.id);
|
||||
expect(run.scenarioVersion).toBe(2);
|
||||
expect(outputs(run)).toEqual(["latest"]);
|
||||
});
|
||||
|
||||
it("runs an older version's steps when asked", async () => {
|
||||
const sc = await scenarioService.create({ name: `old-${uniq()}` });
|
||||
const step = await scenarioService.createStep(sc.id, {
|
||||
title: "first",
|
||||
execCode: "return 'v2';",
|
||||
});
|
||||
await scenarioService.updateStep(sc.id, step.id, {
|
||||
execCode: "return 'v3';",
|
||||
});
|
||||
await scenarioService.createStep(sc.id, { execCode: "return 'extra';" });
|
||||
|
||||
const run = await runToCompletion(sc.id, 2);
|
||||
expect(run.scenarioVersion).toBe(2);
|
||||
expect(run.stepRuns).toHaveLength(1);
|
||||
expect(run.stepRuns[0].title).toBe("first");
|
||||
expect(run.stepRuns[0].execCode).toBe("return 'v2';");
|
||||
expect(outputs(run)).toEqual(["v2"]);
|
||||
});
|
||||
|
||||
it("rejects a version that does not exist", async () => {
|
||||
const sc = await scenarioService.create({ name: `nov-${uniq()}` });
|
||||
const environmentId = await createEnvironment();
|
||||
await request(app.getHttpServer())
|
||||
.post(`/scenarios/${sc.id}/run`)
|
||||
.send({ environmentId, version: 7 })
|
||||
.expect(404);
|
||||
});
|
||||
|
||||
it("keeps run history when a step is deleted", async () => {
|
||||
const sc = await scenarioService.create({ name: `hist-${uniq()}` });
|
||||
const step = await scenarioService.createStep(sc.id, {
|
||||
execCode: "return 1;",
|
||||
});
|
||||
const run = await runToCompletion(sc.id);
|
||||
await scenarioService.removeStep(sc.id, step.id);
|
||||
|
||||
const after = await scenarioService.findRun(sc.id, run.id);
|
||||
expect(after.stepRuns).toHaveLength(1);
|
||||
expect(after.stepRuns[0].scenarioStepId).toBeNull();
|
||||
expect(after.stepRuns[0].execCode).toBe("return 1;");
|
||||
});
|
||||
});
|
||||
|
||||
// ── snippet versions ──────────────────────────────────────────────────────
|
||||
|
||||
describe("snippet versions", () => {
|
||||
it("bumps on change only and keeps every version", async () => {
|
||||
const alias = `snip-${uniq()}`;
|
||||
const sn = await snippetService.create({
|
||||
alias,
|
||||
title: "t",
|
||||
code: "return 1;",
|
||||
});
|
||||
expect(sn.version).toBe(1);
|
||||
|
||||
await snippetService.update(sn.id, { code: "return 2;" });
|
||||
await snippetService.update(sn.id, { code: "return 2;" }); // no-op
|
||||
expect((await snippetService.findOne(sn.id)).version).toBe(2);
|
||||
|
||||
const versions = await snippetService.listVersions(sn.id);
|
||||
expect(versions.map((v) => [v.version, v.code])).toEqual([
|
||||
[2, "return 2;"],
|
||||
[1, "return 1;"],
|
||||
]);
|
||||
});
|
||||
|
||||
it("runSnippet uses the latest by default and alias@N pins a version", async () => {
|
||||
const alias = `pin-${uniq()}`;
|
||||
const sn = await snippetService.create({
|
||||
alias,
|
||||
title: "t",
|
||||
code: "return 'one';",
|
||||
});
|
||||
await snippetService.update(sn.id, { code: "return 'two';" });
|
||||
|
||||
const sc = await scenarioService.create({ name: `pinned-${uniq()}` });
|
||||
await scenarioService.createStep(sc.id, {
|
||||
execCode: `return [await context.runSnippet("${alias}"), await context.runSnippet("${alias}@1")];`,
|
||||
});
|
||||
|
||||
const run = await runToCompletion(sc.id);
|
||||
expect(run.status).toBe("pass");
|
||||
expect(outputs(run)).toEqual([["two", "one"]]);
|
||||
|
||||
const used = await scenarioService.getUsedSnippets(sc.id);
|
||||
expect(used.map((u) => [u.alias, u.pinnedVersion])).toEqual([
|
||||
[alias, null],
|
||||
[alias, 1],
|
||||
]);
|
||||
});
|
||||
|
||||
it("fails the step for a snippet version that does not exist", async () => {
|
||||
const alias = `missing-${uniq()}`;
|
||||
await snippetService.create({ alias, title: "t", code: "return 1;" });
|
||||
const sc = await scenarioService.create({ name: `miss-${uniq()}` });
|
||||
await scenarioService.createStep(sc.id, {
|
||||
execCode: `return context.runSnippet("${alias}@5");`,
|
||||
});
|
||||
const run = await runToCompletion(sc.id);
|
||||
expect(run.status).toBe("fail");
|
||||
});
|
||||
});
|
||||
|
||||
// ── export / import ───────────────────────────────────────────────────────
|
||||
|
||||
describe("scenario export/import", () => {
|
||||
it("exports the latest version, or the one asked for", async () => {
|
||||
const sc = await scenarioService.create({ name: `exp-${uniq()}` });
|
||||
await scenarioService.createStep(sc.id, { execCode: "return 1;" });
|
||||
|
||||
const latest = await scenarioService.exportScenario(sc.id, {
|
||||
includeEnvironment: false,
|
||||
credentialIds: [],
|
||||
});
|
||||
expect(latest[latest.length - 1]).toMatchObject({
|
||||
version: 2,
|
||||
steps: [{ execCode: "return 1;" }],
|
||||
});
|
||||
|
||||
const first = await scenarioService.exportScenario(sc.id, {
|
||||
includeEnvironment: false,
|
||||
credentialIds: [],
|
||||
version: 1,
|
||||
});
|
||||
expect(first[first.length - 1]).toMatchObject({ version: 1, steps: [] });
|
||||
});
|
||||
|
||||
it("restores exact versions by id + version", async () => {
|
||||
const id = crypto.randomUUID();
|
||||
const base = { kind: "scenario" as const, id, name: "imported" };
|
||||
|
||||
// New scenario: stored under the given version
|
||||
let sc = await scenarioService.importScenario({
|
||||
...base,
|
||||
version: 3,
|
||||
steps: [{ title: null, execCode: "return 3;" }],
|
||||
});
|
||||
expect(sc.version).toBe(3);
|
||||
expect(await versionNumbers(id)).toEqual([3]);
|
||||
|
||||
// Same version again: left untouched
|
||||
sc = await scenarioService.importScenario({
|
||||
...base,
|
||||
name: "changed",
|
||||
version: 3,
|
||||
steps: [],
|
||||
});
|
||||
expect(sc.name).toBe("imported");
|
||||
expect(sc.steps).toHaveLength(1);
|
||||
|
||||
// Lower, missing version: stored, latest unchanged
|
||||
sc = await scenarioService.importScenario({
|
||||
...base,
|
||||
version: 1,
|
||||
steps: [{ title: null, execCode: "return 1;" }],
|
||||
});
|
||||
expect(sc.version).toBe(3);
|
||||
expect(await versionNumbers(id)).toEqual([3, 1]);
|
||||
expect((await scenarioService.findVersion(id, 1)).steps[0].execCode).toBe(
|
||||
"return 1;",
|
||||
);
|
||||
|
||||
// Higher version: becomes the latest
|
||||
sc = await scenarioService.importScenario({
|
||||
...base,
|
||||
name: "v5",
|
||||
version: 5,
|
||||
steps: [{ title: null, execCode: "return 5;" }],
|
||||
});
|
||||
expect(sc.version).toBe(5);
|
||||
expect(sc.name).toBe("v5");
|
||||
expect(sc.steps.map((s) => s.execCode)).toEqual(["return 5;"]);
|
||||
expect(await versionNumbers(id)).toEqual([5, 3, 1]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("snippet export/import", () => {
|
||||
it("export includes the version and import requires it", async () => {
|
||||
const alias = `sexp-${uniq()}`;
|
||||
const sn = await snippetService.create({
|
||||
alias,
|
||||
title: "t",
|
||||
code: "return 1;",
|
||||
});
|
||||
await snippetService.update(sn.id, { code: "return 2;" });
|
||||
|
||||
const latest = await request(app.getHttpServer())
|
||||
.get(`/snippets/${sn.id}/export`)
|
||||
.expect(200);
|
||||
expect(latest.body).toMatchObject({ version: 2, code: "return 2;" });
|
||||
|
||||
const first = await request(app.getHttpServer())
|
||||
.get(`/snippets/${sn.id}/export?version=1`)
|
||||
.expect(200);
|
||||
expect(first.body).toMatchObject({ version: 1, code: "return 1;" });
|
||||
|
||||
await request(app.getHttpServer())
|
||||
.post("/snippets/import")
|
||||
.send({ alias: `noversion-${uniq()}`, code: "return 0;" })
|
||||
.expect(400);
|
||||
});
|
||||
|
||||
it("restores exact versions by id + version", async () => {
|
||||
const id = crypto.randomUUID();
|
||||
const alias = `simp-${uniq()}`;
|
||||
const base = { kind: "snippet" as const, id, alias, title: "t" };
|
||||
|
||||
let sn = await snippetService.importSnippet({
|
||||
...base,
|
||||
version: 2,
|
||||
code: "return 2;",
|
||||
});
|
||||
expect(sn.version).toBe(2);
|
||||
|
||||
sn = await snippetService.importSnippet({
|
||||
...base,
|
||||
version: 2,
|
||||
code: "changed",
|
||||
});
|
||||
expect(sn.code).toBe("return 2;");
|
||||
|
||||
sn = await snippetService.importSnippet({
|
||||
...base,
|
||||
version: 1,
|
||||
code: "return 1;",
|
||||
});
|
||||
expect(sn.version).toBe(2);
|
||||
|
||||
sn = await snippetService.importSnippet({
|
||||
...base,
|
||||
version: 4,
|
||||
code: "return 4;",
|
||||
});
|
||||
expect(sn.version).toBe(4);
|
||||
expect(sn.code).toBe("return 4;");
|
||||
expect(
|
||||
(await snippetService.listVersions(id)).map((v) => v.version),
|
||||
).toEqual([4, 2, 1]);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user