340 lines
17 KiB
TypeScript
340 lines
17 KiB
TypeScript
import { describe, expect, test } from "vitest";
|
|
import { defaultAppRoleSeeds, defaultPermissionSeedDescriptors } from "@toolctrl/db/permissions-seed.server";
|
|
import { missingReadinessEnv } from "./run-playwright-a11y.mjs";
|
|
|
|
import {
|
|
E2E_READINESS_API_KEY_ALIAS,
|
|
E2E_READINESS_API_LOG_ENDPOINT,
|
|
E2E_READINESS_API_LOG_METHOD,
|
|
E2E_READINESS_PLUGIN_ID,
|
|
E2E_READINESS_PLUGIN_VERSION,
|
|
E2E_READINESS_WEBHOOK_WORKFLOW_ID,
|
|
E2E_READINESS_WAITING_EXECUTION_ID,
|
|
E2E_READINESS_WAITING_MANUAL_BLOCK_EXECUTION_ID,
|
|
E2E_READINESS_WAITING_WORKFLOW_ID,
|
|
E2E_READINESS_WORKFLOW_EXECUTION_ID,
|
|
E2E_READINESS_WORKFLOW_ID,
|
|
E2E_READINESS_WORKFLOW_LOG_BLOCK_EXECUTION_ID,
|
|
E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_ASSERTION,
|
|
E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_BLOCKER,
|
|
E2E_READINESS_LIFECYCLE_PLUGIN_ID,
|
|
E2E_READINESS_LIFECYCLE_PLUGIN_VERSION,
|
|
E2E_READINESS_NO_TENANT_EMAIL,
|
|
E2E_READINESS_NO_TENANT_PASSWORD,
|
|
E2E_READINESS_PLUGIN_READONLY_EMAIL,
|
|
E2E_READINESS_PLUGIN_READONLY_PASSWORD,
|
|
E2E_READINESS_PLUGIN_READONLY_ROLE_NAME,
|
|
E2E_READINESS_SUBSCRIPTION_PLAN_STRIPE_ID,
|
|
E2E_READINESS_SUBSCRIPTION_PRICE_STRIPE_ID,
|
|
E2E_READINESS_TENANT_NAME,
|
|
E2E_READINESS_TENANT_SLUG,
|
|
E2E_READINESS_UPGRADE_PLAN_STRIPE_ID,
|
|
E2E_READINESS_UPGRADE_PRICE_STRIPE_ID,
|
|
E2E_READINESS_USER_EMAIL,
|
|
E2E_READINESS_USER_PASSWORD,
|
|
appFixturePath,
|
|
assertCanRunE2eReadinessSeed,
|
|
buildE2eReadinessEnv,
|
|
buildE2eReadinessEmailSequenceDefinitions,
|
|
buildE2eReadinessLifecyclePluginManifest,
|
|
buildE2eReadinessManualWorkflowDefinition,
|
|
buildE2eReadinessPluginManifest,
|
|
buildE2eReadinessPluginSettingsHtml,
|
|
buildE2eReadinessWaitingWorkflowDefinition,
|
|
buildE2eReadinessWebhookWorkflowDefinition,
|
|
renderE2eReadinessEnvFile,
|
|
} from "./seed-e2e-readiness";
|
|
|
|
describe("seed-e2e-readiness", () => {
|
|
test("refuses production and requires an explicit local opt-in", () => {
|
|
expect(() =>
|
|
assertCanRunE2eReadinessSeed({
|
|
DATABASE_URL: "postgresql://localhost/app",
|
|
E2E_LOCAL_READINESS_SEED: "1",
|
|
NODE_ENV: "production",
|
|
})
|
|
).toThrow("production");
|
|
|
|
expect(() =>
|
|
assertCanRunE2eReadinessSeed({
|
|
DATABASE_URL: "postgresql://localhost/app",
|
|
NODE_ENV: "development",
|
|
})
|
|
).toThrow("E2E_LOCAL_READINESS_SEED=1");
|
|
|
|
expect(() =>
|
|
assertCanRunE2eReadinessSeed({
|
|
E2E_LOCAL_READINESS_SEED: "1",
|
|
NODE_ENV: "development",
|
|
})
|
|
).toThrow("DATABASE_URL");
|
|
});
|
|
|
|
test("builds the readiness env contract consumed by the Playwright gate", () => {
|
|
const env = buildE2eReadinessEnv({
|
|
tenantSlug: E2E_READINESS_TENANT_SLUG,
|
|
workflowId: "wf_123",
|
|
webhookWorkflowId: "wf_webhook_123",
|
|
waitingWorkflowId: "wf_waiting_123",
|
|
waitingExecutionId: "wfe_waiting_123",
|
|
pluginBasePath: "/tmp/e2e-plugins",
|
|
});
|
|
|
|
expect(env).toMatchObject({
|
|
E2E_TENANT_EMAIL: E2E_READINESS_USER_EMAIL,
|
|
E2E_TENANT_PASSWORD: E2E_READINESS_USER_PASSWORD,
|
|
E2E_NO_TENANT_EMAIL: E2E_READINESS_NO_TENANT_EMAIL,
|
|
E2E_NO_TENANT_PASSWORD: E2E_READINESS_NO_TENANT_PASSWORD,
|
|
E2E_PLUGIN_READONLY_EMAIL: E2E_READINESS_PLUGIN_READONLY_EMAIL,
|
|
E2E_PLUGIN_READONLY_PASSWORD: E2E_READINESS_PLUGIN_READONLY_PASSWORD,
|
|
E2E_TENANT_ACCOUNT_NAME: E2E_READINESS_TENANT_NAME,
|
|
E2E_TENANT_ACCOUNT_SLUG: E2E_READINESS_TENANT_SLUG,
|
|
E2E_REGISTRATION_EXPECTS_EMAIL_VERIFICATION: "0",
|
|
E2E_TENANT_DASHBOARD_PATH: "/e2e-readiness/dashboard",
|
|
E2E_TENANT_SETTINGS_ACCOUNT_PATH: "/e2e-readiness/settings/account",
|
|
E2E_TENANT_SETTINGS_PROFILE_PATH: "/e2e-readiness/settings/profile",
|
|
E2E_TENANT_SUBSCRIPTION_PATH: "/e2e-readiness/settings/subscription",
|
|
E2E_TENANT_MEMBERS_PATH: "/e2e-readiness/settings/members",
|
|
E2E_TENANT_ROLES_AND_PERMISSIONS_PATH: "/e2e-readiness/settings/roles-and-permissions",
|
|
E2E_TENANT_NOTIFICATIONS_PATH: "/e2e-readiness/settings/notifications",
|
|
E2E_TENANT_LOGS_PATH: "/e2e-readiness/settings/logs",
|
|
E2E_TENANT_LOG_EVENTS_PATH: "/e2e-readiness/settings/logs/events",
|
|
E2E_TENANT_AUDIT_EXPORT_PATH: "/e2e-readiness/settings/audit-export",
|
|
E2E_TENANT_PRIVACY_PATH: "/e2e-readiness/settings/privacy",
|
|
E2E_TENANT_CHATBOT_PATH: "/e2e-readiness/settings/chatbot",
|
|
E2E_TENANT_AI_USAGE_PATH: "/e2e-readiness/settings/ai-usage",
|
|
E2E_TENANT_API_PATH: "/e2e-readiness/settings/api",
|
|
E2E_TENANT_API_KEYS_PATH: "/e2e-readiness/settings/api/keys",
|
|
E2E_TENANT_API_DOCS_PATH: "/e2e-readiness/settings/api/docs",
|
|
E2E_TENANT_API_LOGS_PATH: "/e2e-readiness/settings/api/logs",
|
|
E2E_TENANT_POLICIES_PATH: "/e2e-readiness/settings/policies",
|
|
E2E_ADMIN_EMAIL_SEQUENCES_PATH: "/email-sequences",
|
|
E2E_PLUGIN_SETTINGS_PATH: "/e2e-readiness/settings/plugins",
|
|
E2E_WORKFLOW_ENGINE_PATH: "/e2e-readiness/workflow-engine/workflows",
|
|
E2E_WORKFLOW_BUILDER_PATH: "/e2e-readiness/workflow-engine/workflows/wf_123",
|
|
E2E_WORKFLOW_RUN_API_PATH: "/e2e-readiness/workflow-engine/workflows/wf_123/run/api",
|
|
E2E_WORKFLOW_RUN_MANUAL_PATH: "/e2e-readiness/workflow-engine/workflows/wf_123/run/manual",
|
|
E2E_WORKFLOW_WEBHOOK_BUILDER_PATH: "/e2e-readiness/workflow-engine/workflows/wf_webhook_123",
|
|
E2E_WORKFLOW_WEBHOOK_RUN_MANUAL_PATH: "/e2e-readiness/workflow-engine/workflows/wf_webhook_123/run/manual",
|
|
E2E_WORKFLOW_WAITING_BUILDER_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123",
|
|
E2E_WORKFLOW_WAITING_RUN_MANUAL_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123/run/manual",
|
|
E2E_WORKFLOW_WAITING_RUN_API_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123/run/api",
|
|
E2E_WORKFLOW_WAITING_EXECUTIONS_PATH: "/e2e-readiness/workflow-engine/workflows/wf_waiting_123/executions",
|
|
E2E_WORKFLOW_WAITING_EXECUTION_ID: "wfe_waiting_123",
|
|
E2E_ALLOW_WORKFLOW_RUN: "1",
|
|
E2E_ALLOW_WORKFLOW_WEBHOOK_RUN: "0",
|
|
E2E_WORKFLOW_WEBHOOK_TARGET_URL: "",
|
|
E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN: "0",
|
|
E2E_WORKFLOW_OUTBOX_DRAIN_EXPECTED_STATUS: "success",
|
|
E2E_WORKFLOW_OUTBOX_DRAIN_ASSERTION: "operator-gated",
|
|
E2E_WORKFLOW_OUTBOX_DRAIN_BLOCKER:
|
|
"Workflow outbox-drain readiness is operator-gated: set E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN=1 only when the general worker is running and the seeded manual workflow can reach the expected success execution status.",
|
|
PLUGIN_BINARY_BASE_PATH: "/tmp/e2e-plugins",
|
|
});
|
|
|
|
expect(missingReadinessEnv({ env })).toEqual([]);
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_EMAIL="e2e.readiness@example.test"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_NO_TENANT_EMAIL="e2e.no-tenant@example.test"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_NO_TENANT_PASSWORD="NoTenantPass123!"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_PLUGIN_READONLY_EMAIL="e2e.plugin-readonly@example.test"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_PLUGIN_READONLY_PASSWORD="PluginReadOnlyPass123!"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_REGISTRATION_EXPECTS_EMAIL_VERIFICATION="0"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_SETTINGS_ACCOUNT_PATH="/e2e-readiness/settings/account"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_MEMBERS_PATH="/e2e-readiness/settings/members"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_PRIVACY_PATH="/e2e-readiness/settings/privacy"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_AI_USAGE_PATH="/e2e-readiness/settings/ai-usage"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_TENANT_API_LOGS_PATH="/e2e-readiness/settings/api/logs"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_ADMIN_EMAIL_SEQUENCES_PATH="/email-sequences"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_ALLOW_WORKFLOW_WEBHOOK_RUN="0"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_WEBHOOK_TARGET_URL=""');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_WAITING_EXECUTIONS_PATH="/e2e-readiness/workflow-engine/workflows/wf_waiting_123/executions"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_WAITING_EXECUTION_ID="wfe_waiting_123"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN="0"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_OUTBOX_DRAIN_EXPECTED_STATUS="success"');
|
|
expect(renderE2eReadinessEnvFile(env)).toContain('E2E_WORKFLOW_OUTBOX_DRAIN_ASSERTION="operator-gated"');
|
|
});
|
|
|
|
test("documents workflow outbox-drain readiness as an operator-gated expected-success probe", () => {
|
|
expect(E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_ASSERTION).toBe("operator-gated");
|
|
expect(E2E_READINESS_WORKFLOW_OUTBOX_DRAIN_BLOCKER).toBe(
|
|
"Workflow outbox-drain readiness is operator-gated: set E2E_REQUIRE_WORKFLOW_OUTBOX_DRAIN=1 only when the general worker is running and the seeded manual workflow can reach the expected success execution status."
|
|
);
|
|
});
|
|
|
|
test("defines deterministic API key and log fixture identifiers", () => {
|
|
expect(E2E_READINESS_API_KEY_ALIAS).toBe("E2E Readiness API Key");
|
|
expect(E2E_READINESS_API_LOG_ENDPOINT).toBe("/v1/e2e-readiness");
|
|
expect(E2E_READINESS_API_LOG_METHOD).toBe("GET");
|
|
});
|
|
|
|
test("defines separate owned and unowned subscription fixtures for billing smokes", () => {
|
|
expect(E2E_READINESS_SUBSCRIPTION_PLAN_STRIPE_ID).toBe("e2e_readiness_plan");
|
|
expect(E2E_READINESS_SUBSCRIPTION_PRICE_STRIPE_ID).toBe("e2e_readiness_price_monthly");
|
|
expect(E2E_READINESS_UPGRADE_PLAN_STRIPE_ID).toBe("e2e_readiness_upgrade_plan");
|
|
expect(E2E_READINESS_UPGRADE_PRICE_STRIPE_ID).toBe("e2e_readiness_upgrade_price_monthly");
|
|
});
|
|
|
|
test("keeps the plugin read-only fixture on the default User app role contract", () => {
|
|
expect(E2E_READINESS_PLUGIN_READONLY_EMAIL).toBe("e2e.plugin-readonly@example.test");
|
|
expect(E2E_READINESS_PLUGIN_READONLY_PASSWORD).toBe("PluginReadOnlyPass123!");
|
|
expect(E2E_READINESS_PLUGIN_READONLY_ROLE_NAME).toBe("User");
|
|
expect(defaultAppRoleSeeds.find((role) => role.name === E2E_READINESS_PLUGIN_READONLY_ROLE_NAME)).toMatchObject({
|
|
type: "app",
|
|
assignToNewUsers: true,
|
|
});
|
|
|
|
expect(defaultPermissionSeedDescriptors.find((permission) => permission.name === "app.plugins.use")?.inRoles).toContain(
|
|
E2E_READINESS_PLUGIN_READONLY_ROLE_NAME
|
|
);
|
|
expect(defaultPermissionSeedDescriptors.find((permission) => permission.name === "app.plugins.manage")?.inRoles).not.toContain(
|
|
E2E_READINESS_PLUGIN_READONLY_ROLE_NAME
|
|
);
|
|
});
|
|
|
|
test("keeps the plugin fixture shaped for consent, revoke, and iframe settings coverage", () => {
|
|
const manifest = buildE2eReadinessPluginManifest();
|
|
|
|
expect(manifest.id).toBe(E2E_READINESS_PLUGIN_ID);
|
|
expect(manifest.version).toBe(E2E_READINESS_PLUGIN_VERSION);
|
|
expect(manifest.capabilities.map((capability) => capability.name)).toEqual(["log", "audit"]);
|
|
expect(manifest.hooks).toEqual([{ name: "workflow.executed", export: "onWorkflowExecuted" }]);
|
|
expect(manifest.ui?.settings?.entry).toBe("settings/index.html");
|
|
expect(manifest.ui?.settings?.sha256).toMatch(/^[a-f0-9]{64}$/u);
|
|
});
|
|
|
|
test("keeps the plugin settings HTML compatible with the hardened iframe protocol", () => {
|
|
const html = buildE2eReadinessPluginSettingsHtml();
|
|
|
|
expect(html).toContain('meta[name="plugin-id"]');
|
|
expect(html).toContain('meta[name="plugin-settings-channel"]');
|
|
expect(html).toContain('meta[name="plugin-settings-protocol"]');
|
|
expect(html).toContain("parent.postMessage");
|
|
expect(html).toContain("type: 'plugin.settings.set'");
|
|
expect(html).toContain("version: protocolVersion");
|
|
expect(html).toContain("pluginId: pluginId");
|
|
expect(html).toContain("channelId: channelId");
|
|
expect(html).toContain("requestId: 'seed-fixture-save'");
|
|
expect(html).toContain("key: 'theme'");
|
|
expect(html).toContain("value: 'ready'");
|
|
expect(html).toContain("<script>");
|
|
expect(html).not.toContain("onclick=");
|
|
});
|
|
|
|
test("keeps a separate plugin fixture for real lifecycle persistence coverage", () => {
|
|
const manifest = buildE2eReadinessLifecyclePluginManifest();
|
|
|
|
expect(manifest.id).toBe(E2E_READINESS_LIFECYCLE_PLUGIN_ID);
|
|
expect(manifest.version).toBe(E2E_READINESS_LIFECYCLE_PLUGIN_VERSION);
|
|
expect(manifest.capabilities.map((capability) => capability.name)).toEqual(["log", "audit"]);
|
|
expect(manifest.hooks).toEqual([{ name: "workflow.executed", export: "onWorkflowExecuted" }]);
|
|
expect(manifest.ui?.settings).toBeUndefined();
|
|
});
|
|
|
|
test("defines deterministic workflow graph fixtures for log-only and webhook readiness", () => {
|
|
expect(E2E_READINESS_WORKFLOW_EXECUTION_ID).toBe("wfe_123");
|
|
expect(E2E_READINESS_WORKFLOW_LOG_BLOCK_EXECUTION_ID).toBe("wfbe_log_123");
|
|
|
|
expect(buildE2eReadinessManualWorkflowDefinition()).toMatchObject({
|
|
id: E2E_READINESS_WORKFLOW_ID,
|
|
blocks: [
|
|
{ key: "manual", type: "manual", isTrigger: true, isBlock: false, input: {} },
|
|
{ key: "log", type: "log", isTrigger: false, isBlock: true, input: { message: "E2E readiness {{$params.message}}" } },
|
|
],
|
|
edges: [{ from: "manual", to: "log" }],
|
|
inputExample: { title: "Readiness payload", input: { message: "ready" } },
|
|
});
|
|
|
|
expect(buildE2eReadinessWebhookWorkflowDefinition()).toMatchObject({
|
|
id: E2E_READINESS_WEBHOOK_WORKFLOW_ID,
|
|
blocks: [
|
|
{ key: "manual", type: "manual", isTrigger: true, isBlock: false, input: {} },
|
|
{
|
|
key: "httpRequest",
|
|
type: "httpRequest",
|
|
isTrigger: false,
|
|
isBlock: true,
|
|
input: {
|
|
url: "{{$params.webhookUrl}}",
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: '{"message":"{{$params.message}}"}',
|
|
throwsError: true,
|
|
},
|
|
},
|
|
{ key: "log", type: "log", isTrigger: false, isBlock: true, input: { message: "Webhook readiness status {{$httpRequest.statusCode}}" } },
|
|
],
|
|
edges: [
|
|
{ from: "manual", to: "httpRequest" },
|
|
{ from: "httpRequest", to: "log" },
|
|
],
|
|
inputExample: {
|
|
title: "Webhook readiness payload",
|
|
input: { webhookUrl: "http://127.0.0.1:1/e2e-readiness-webhook", message: "ready" },
|
|
},
|
|
});
|
|
|
|
expect(E2E_READINESS_WAITING_WORKFLOW_ID).toBe("wf_waiting_123");
|
|
expect(E2E_READINESS_WAITING_EXECUTION_ID).toBe("wfe_waiting_123");
|
|
expect(E2E_READINESS_WAITING_MANUAL_BLOCK_EXECUTION_ID).toBe("wfbe_waiting_manual_123");
|
|
expect(buildE2eReadinessWaitingWorkflowDefinition()).toMatchObject({
|
|
id: E2E_READINESS_WAITING_WORKFLOW_ID,
|
|
blocks: [
|
|
{ key: "manual", type: "manual", isTrigger: true, isBlock: false, input: {} },
|
|
{
|
|
key: "wait",
|
|
type: "waitForInput",
|
|
isTrigger: false,
|
|
isBlock: true,
|
|
input: { title: "E2E approval", placeholder: "Type approval" },
|
|
},
|
|
{
|
|
key: "variable",
|
|
type: "variable",
|
|
isTrigger: false,
|
|
isBlock: true,
|
|
input: { variableName: "approvalMessage", value: "approved {{waitForInput.input.approved}}" },
|
|
},
|
|
{ key: "log", type: "log", isTrigger: false, isBlock: true, input: { message: "continued {{$vars.approvalMessage}}" } },
|
|
],
|
|
edges: [
|
|
{ from: "manual", to: "wait" },
|
|
{ from: "wait", to: "variable" },
|
|
{ from: "variable", to: "log" },
|
|
],
|
|
inputExample: { title: "Waiting readiness payload", input: { input: { approved: false } } },
|
|
});
|
|
});
|
|
|
|
test("defines deterministic email sequence fixtures for admin and trigger readiness", () => {
|
|
const sequences = buildE2eReadinessEmailSequenceDefinitions("tenant_123");
|
|
|
|
expect(sequences).toHaveLength(4);
|
|
expect(sequences.map((sequence) => sequence.id)).toEqual([
|
|
"seq_e2e_welcome",
|
|
"seq_e2e_trial_expiring",
|
|
"seq_e2e_stale_lead",
|
|
"seq_e2e_customer_welcome",
|
|
]);
|
|
expect(sequences.map((sequence) => sequence.triggerEvent)).toEqual([
|
|
"tenant.signup",
|
|
"tenant.trial_expiring",
|
|
"lead.stale_60d",
|
|
"lead.converted_to_customer",
|
|
]);
|
|
expect(sequences.every((sequence) => sequence.tenantId === "tenant_123")).toBe(true);
|
|
expect(sequences.every((sequence) => sequence.isEnabled)).toBe(true);
|
|
expect(sequences.every((sequence) => sequence.steps.length === 1)).toBe(true);
|
|
expect(sequences.map((sequence) => sequence.steps[0]?.template)).toEqual([
|
|
"welcome",
|
|
"trial-reminder",
|
|
"re-activation",
|
|
"generic-step",
|
|
]);
|
|
});
|
|
|
|
test("normalizes app fixture paths without host assumptions", () => {
|
|
expect(appFixturePath("acme", "dashboard")).toBe("/acme/dashboard");
|
|
expect(appFixturePath("acme", "/settings/subscription")).toBe("/acme/settings/subscription");
|
|
});
|
|
});
|