droboticflow/scripts/object-storage-acceptance.mjs
2026-06-16 17:56:50 +08:00

296 lines
11 KiB
JavaScript

import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { chromium } from "playwright";
const BASE_URL = (process.env.BASE_URL || process.env.API_BASE_URL || "http://127.0.0.1:3001").replace(/\/+$/, "");
const API_TOKEN = (process.env.DROBOTICFLOW_API_TOKEN || "").trim();
const SMOKE_EMAIL = (process.env.DROBOTICFLOW_SMOKE_EMAIL || "").trim();
const SMOKE_PASSWORD = process.env.DROBOTICFLOW_SMOKE_PASSWORD || "";
const CONNECTION_ID = (process.env.OBJECT_STORAGE_CONNECTION_ID || "").trim();
const CONNECTION_NAME = (process.env.OBJECT_STORAGE_CONNECTION_NAME || "").trim();
const CONFIGURED_BUCKET = (process.env.OBJECT_STORAGE_BUCKET || "").trim();
const VIDEO_KEY = (process.env.OBJECT_STORAGE_VIDEO_KEY || "").trim();
const IGNORE_HTTPS_ERRORS = /^(1|true|yes)$/i.test(process.env.PLAYWRIGHT_IGNORE_HTTPS_ERRORS || "");
const testPrefix = `object-storage-acceptance-${Date.now()}`;
const createdKey = `${testPrefix}/object-storage-test.json`;
const renamedKey = `${testPrefix}/object-storage-renamed.json`;
const uploadKey = `${testPrefix}/nested/object-upload.txt`;
const uploadPayload = "upload payload from object storage acceptance";
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "droboticflow-object-storage-"));
const uploadFilePath = path.join(tmpDir, "object-storage-upload.txt");
fs.writeFileSync(uploadFilePath, uploadPayload, "utf8");
if (Boolean(SMOKE_EMAIL) !== Boolean(SMOKE_PASSWORD)) {
throw new Error("DROBOTICFLOW_SMOKE_EMAIL and DROBOTICFLOW_SMOKE_PASSWORD must be set together");
}
function csrfProtectedMethod(method) {
return !["GET", "HEAD", "OPTIONS"].includes(method.toUpperCase());
}
async function csrfToken(context) {
const cookies = await context.cookies(BASE_URL);
const cookie = cookies.find((item) => item.name === "droboticflow_csrf");
return cookie?.value ? decodeURIComponent(cookie.value) : "";
}
async function apiRequest(
context,
pathName,
{ method = "GET", body, headers = {}, expected = [200, 201, 202, 204] } = {},
) {
const requestHeaders = { ...headers };
if (API_TOKEN) {
requestHeaders.Authorization = `Bearer ${API_TOKEN}`;
}
if (body !== undefined && !requestHeaders["Content-Type"]) {
requestHeaders["Content-Type"] = "application/json";
}
if (csrfProtectedMethod(method)) {
const token = await csrfToken(context);
if (token) {
requestHeaders["X-Droboticflow-CSRF-Token"] = token;
}
}
const response = await context.request.fetch(`${BASE_URL}${pathName}`, {
method,
headers: requestHeaders,
data: body === undefined ? undefined : JSON.stringify(body),
});
const text = await response.text();
if (!expected.includes(response.status())) {
throw new Error(`${method} ${pathName} failed with ${response.status()}: ${text}`);
}
return text ? JSON.parse(text) : null;
}
async function loginIfConfigured(context) {
if (!SMOKE_EMAIL) {
return;
}
const response = await apiRequest(context, "/api/auth/login", {
method: "POST",
body: {
email: SMOKE_EMAIL,
password: SMOKE_PASSWORD,
},
expected: [200],
});
console.log(`logged in object-storage acceptance user: ${response?.email || response?.name || SMOKE_EMAIL}`);
}
async function resolveConnection(context) {
const payload = await apiRequest(context, "/api/storage/connections");
const items = payload?.items || [];
let matched = null;
if (CONNECTION_ID) {
matched = items.find((item) => item.id === CONNECTION_ID);
} else if (CONNECTION_NAME) {
matched = items.find((item) => item.name === CONNECTION_NAME);
} else if (CONFIGURED_BUCKET) {
matched = items.find((item) => item.bucket === CONFIGURED_BUCKET);
} else {
throw new Error(
"Set OBJECT_STORAGE_CONNECTION_ID, OBJECT_STORAGE_CONNECTION_NAME, or OBJECT_STORAGE_BUCKET before running object-storage acceptance",
);
}
if (!matched?.id) {
const selectors = [
CONNECTION_ID && `id=${CONNECTION_ID}`,
CONNECTION_NAME && `name=${CONNECTION_NAME}`,
CONFIGURED_BUCKET && `bucket=${CONFIGURED_BUCKET}`,
]
.filter(Boolean)
.join(", ");
throw new Error(`No storage connection matched ${selectors || "the configured selector"}`);
}
return matched;
}
function objectStoragePath(pathName, connectionId, bucket, params = {}) {
const search = new URLSearchParams({ connectionId });
if (bucket) {
search.set("bucket", bucket);
}
for (const [key, value] of Object.entries(params)) {
if (value !== undefined && value !== "") {
search.set(key, String(value));
}
}
return `${pathName}?${search.toString()}`;
}
async function cleanupArtifacts(context, connectionId, bucket) {
try {
await apiRequest(
context,
objectStoragePath("/api/object-storage/objects", connectionId, bucket, {
key: testPrefix,
recursive: "true",
}),
{
method: "DELETE",
expected: [200, 204, 404],
},
);
} catch (error) {
console.warn(`cleanup skipped: ${error instanceof Error ? error.message : String(error)}`);
}
}
async function waitForObjectRow(page, key) {
const locator = page.locator(`[data-object-key=${JSON.stringify(key)}]`);
await locator.waitFor({ state: "visible" });
return locator;
}
async function openObjectKey(page, key) {
const segments = key.split("/").filter(Boolean);
assert.ok(segments.length > 0, "OBJECT_STORAGE_VIDEO_KEY must not be empty");
await page.click('button:has-text("根目录")');
let prefix = "";
for (const segment of segments.slice(0, -1)) {
prefix = prefix ? `${prefix}/${segment}` : segment;
await waitForObjectRow(page, prefix);
await page.dblclick(`[data-object-key=${JSON.stringify(prefix)}]`);
}
await waitForObjectRow(page, key);
await page.click(`[data-object-key=${JSON.stringify(key)}]`);
}
async function run() {
const browser = await chromium.launch({ headless: true });
const context = await browser.newContext({
extraHTTPHeaders: API_TOKEN ? { Authorization: `Bearer ${API_TOKEN}` } : undefined,
ignoreHTTPSErrors: IGNORE_HTTPS_ERRORS,
});
let connection = null;
let bucketName = "";
try {
await loginIfConfigured(context);
connection = await resolveConnection(context);
bucketName = CONFIGURED_BUCKET || connection.bucket || "";
assert.ok(
bucketName,
"Selected storage connection has no bound bucket; set OBJECT_STORAGE_BUCKET for object-storage acceptance",
);
const page = await context.newPage();
page.on("dialog", (dialog) => dialog.accept());
await page.goto(`${BASE_URL}/object-storage`, { waitUntil: "networkidle" });
await page.waitForSelector('[data-testid="object-storage-connection-select"]');
await page.waitForFunction(
(id) =>
Array.from(
document.querySelector('[data-testid="object-storage-connection-select"]')?.querySelectorAll("option") || [],
).some((option) => option.value === id),
connection.id,
);
await page.selectOption('[data-testid="object-storage-connection-select"]', connection.id);
await page.waitForSelector('[data-testid="bound-bucket-name"]');
await page.waitForFunction(
(expected) => document.querySelector('[data-testid="bound-bucket-name"]')?.textContent?.includes(expected),
bucketName,
);
await page.click('[data-testid="object-create-draft-button"]');
await page.fill('[data-testid="object-key-input"]', createdKey);
await page.fill('[data-testid="object-content-type-input"]', "application/json");
await page.fill(
'[data-testid="object-editor"]',
JSON.stringify({ message: "hello object storage", source: "playwright" }, null, 2),
);
await page.click('[data-testid="object-save-button"]');
await waitForObjectRow(page, testPrefix);
await page.dblclick(`[data-object-key=${JSON.stringify(testPrefix)}]`);
await waitForObjectRow(page, createdKey);
await page.click(`[data-object-key=${JSON.stringify(createdKey)}]`);
await page.waitForFunction(() => {
const preview = document.querySelector("pre");
return preview && preview.textContent?.includes("hello object storage");
});
await page.fill('[data-testid="rename-key-input"]', renamedKey);
await page.click('[data-testid="object-rename-button"]');
await waitForObjectRow(page, renamedKey);
await page.fill('[data-testid="upload-key-input"]', uploadKey);
await page.setInputFiles('[data-testid="upload-file-input"]', uploadFilePath);
await page.click('[data-testid="object-upload-button"]');
await waitForObjectRow(page, `${testPrefix}/nested`);
await page.dblclick(`[data-object-key=${JSON.stringify(`${testPrefix}/nested`)}]`);
await waitForObjectRow(page, uploadKey);
await page.click(`[data-object-key=${JSON.stringify(uploadKey)}]`);
await page.waitForFunction((text) => {
const preview = document.querySelector("pre");
return preview && preview.textContent?.includes(text);
}, uploadPayload);
await page.click('button:has-text("返回上级")');
await waitForObjectRow(page, renamedKey);
await page.click(`[data-object-key=${JSON.stringify(renamedKey)}]`);
await page.click('[data-testid="object-delete-button"]');
await page.waitForFunction(
(key) => !document.querySelector(`[data-object-key=${JSON.stringify(key)}]`),
renamedKey,
);
await page.click(`[data-object-key=${JSON.stringify(`${testPrefix}/nested`)}]`);
await page.click('[data-testid="object-delete-button"]');
await page.waitForFunction(
(key) => !document.querySelector(`[data-object-key=${JSON.stringify(key)}]`),
`${testPrefix}/nested`,
);
if (VIDEO_KEY) {
await openObjectKey(page, VIDEO_KEY);
await page.waitForSelector("video");
await page.waitForFunction(() => {
const element = document.querySelector("video");
return element && element.readyState >= 2;
});
}
const overview = await apiRequest(context, objectStoragePath("/api/object-storage", connection.id, bucketName));
assert.equal(overview?.bucket, bucketName, "expected bound bucket in overview");
console.log(
JSON.stringify(
{
baseUrl: BASE_URL,
connectionId: connection.id,
bucket: bucketName,
testPrefix,
verifiedVideoKey: VIDEO_KEY || null,
status: "ok",
},
null,
2,
),
);
} finally {
if (connection?.id) {
await cleanupArtifacts(context, connection.id, bucketName);
}
await browser.close();
fs.rmSync(tmpDir, { recursive: true, force: true });
}
}
run().catch((error) => {
console.error(error);
process.exitCode = 1;
});