635 lines
27 KiB
JavaScript
635 lines
27 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import { execFileSync, spawnSync } from 'node:child_process';
|
|
import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import { dirname, join } from 'node:path';
|
|
|
|
const baseURL = (process.env.GATEWAY_BASE_URL || 'http://127.0.0.1:8088').replace(/\/+$/, '');
|
|
const platformKey = process.env.KELING_VIDEO_PLATFORM_KEY || 'transtreams_keling';
|
|
const pollIntervalMs = positiveInteger(process.env.KELING_VIDEO_POLL_INTERVAL_MS, 10_000);
|
|
const taskTimeoutMs = positiveInteger(process.env.KELING_VIDEO_TASK_TIMEOUT_MS, 30 * 60 * 1000);
|
|
const outputPath =
|
|
process.env.KELING_VIDEO_E2E_OUTPUT ||
|
|
`artifacts/keling-video-e2e-${new Date().toISOString().replaceAll(/[:.]/g, '-')}.json`;
|
|
const database = {
|
|
container: process.env.GATEWAY_E2E_DB_CONTAINER || 'postgres',
|
|
name: process.env.GATEWAY_E2E_DB_NAME || 'easyai_ai_gateway',
|
|
user: process.env.GATEWAY_E2E_DB_USER || 'easyai',
|
|
};
|
|
|
|
const validationCases = [
|
|
{
|
|
name: 'compatible-o1-720p-16x9-3s-audio-off',
|
|
interface: 'kling-compatible',
|
|
requestedModel: 'kling-video-o1',
|
|
gatewayModel: 'kling-o1',
|
|
providerModel: 'kling-video-o1',
|
|
request: {
|
|
model_name: 'kling-video-o1',
|
|
prompt: 'A blue ceramic cup rotates slowly on a clean studio table, locked camera, no sound.',
|
|
mode: 'std',
|
|
aspect_ratio: '16:9',
|
|
duration: '3',
|
|
sound: 'off',
|
|
image_list: [
|
|
{
|
|
image_url: 'https://placehold.co/1024x1024/png',
|
|
},
|
|
],
|
|
watermark_info: { enabled: false },
|
|
external_task_id: 'gateway-keling-e2e-compatible-o1',
|
|
},
|
|
expected: { resolution: '720p', shortEdge: 720, ratio: 16 / 9, duration: 3, audio: false },
|
|
},
|
|
{
|
|
name: 'compatible-v3-1080p-9x16-5s-audio-on',
|
|
interface: 'kling-compatible',
|
|
requestedModel: 'kling-v3-omni',
|
|
gatewayModel: 'kling-3.0-omni',
|
|
providerModel: 'kling-v3-omni',
|
|
request: {
|
|
model_name: 'kling-v3-omni',
|
|
prompt: 'Vertical close-up of gentle rain falling on green leaves, with clear natural rain ambience.',
|
|
mode: 'pro',
|
|
aspect_ratio: '9:16',
|
|
duration: 5,
|
|
sound: 'on',
|
|
watermark_info: { enabled: false },
|
|
external_task_id: 'gateway-keling-e2e-compatible-v3',
|
|
},
|
|
expected: { resolution: '1080p', shortEdge: 1080, ratio: 9 / 16, duration: 5, audio: true },
|
|
},
|
|
{
|
|
name: 'standard-o1-1080p-9x16-5s-audio-on',
|
|
interface: 'gateway-standard',
|
|
requestedModel: 'kling-o1',
|
|
gatewayModel: 'kling-o1',
|
|
providerModel: 'kling-video-o1',
|
|
request: {
|
|
model: 'kling-o1',
|
|
prompt: 'Vertical view of small ocean waves reaching a sandy beach, with audible natural surf.',
|
|
resolution: '1080p',
|
|
aspect_ratio: '9:16',
|
|
duration: 5,
|
|
audio: true,
|
|
watermark: false,
|
|
runMode: 'real',
|
|
},
|
|
expected: { resolution: '1080p', shortEdge: 1080, ratio: 9 / 16, duration: 5, audio: true },
|
|
},
|
|
{
|
|
name: 'standard-v3-720p-16x9-3s-audio-off',
|
|
interface: 'gateway-standard',
|
|
requestedModel: 'kling-3.0-omni',
|
|
gatewayModel: 'kling-3.0-omni',
|
|
providerModel: 'kling-v3-omni',
|
|
request: {
|
|
model: 'kling-3.0-omni',
|
|
prompt: 'Wide shot of a paper windmill turning slowly beside a window, locked camera, no sound.',
|
|
resolution: '720p',
|
|
aspect_ratio: '16:9',
|
|
duration: 3,
|
|
audio: false,
|
|
watermark: false,
|
|
runMode: 'real',
|
|
},
|
|
expected: { resolution: '720p', shortEdge: 720, ratio: 16 / 9, duration: 3, audio: false },
|
|
},
|
|
];
|
|
|
|
const selectedNames = new Set(
|
|
String(process.env.KELING_VIDEO_CASES || '')
|
|
.split(',')
|
|
.map((value) => value.trim())
|
|
.filter(Boolean),
|
|
);
|
|
const resumeTaskIds = parseResumeTaskIds(process.env.KELING_VIDEO_RESUME_TASKS);
|
|
const continueOnValidationFailure = process.env.KELING_VIDEO_CONTINUE_ON_VALIDATION_FAILURE === 'true';
|
|
if (selectedNames.size > 0) {
|
|
const selected = validationCases.filter((validationCase) => selectedNames.has(validationCase.name));
|
|
if (selected.length !== selectedNames.size) {
|
|
throw new Error(`Unknown KELING_VIDEO_CASES value; known cases: ${validationCases.map((item) => item.name).join(', ')}`);
|
|
}
|
|
validationCases.splice(0, validationCases.length, ...selected);
|
|
}
|
|
|
|
const submittedTasks = [];
|
|
|
|
function assert(condition, message) {
|
|
if (!condition) throw new Error(message);
|
|
}
|
|
|
|
function positiveInteger(value, fallback) {
|
|
const parsed = Number.parseInt(String(value || ''), 10);
|
|
return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
|
|
}
|
|
|
|
function parseResumeTaskIds(raw) {
|
|
if (!String(raw || '').trim()) return {};
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(raw);
|
|
} catch (error) {
|
|
throw new Error(`KELING_VIDEO_RESUME_TASKS must be a JSON object: ${error.message}`);
|
|
}
|
|
assert(parsed && typeof parsed === 'object' && !Array.isArray(parsed), 'KELING_VIDEO_RESUME_TASKS must be a JSON object');
|
|
return parsed;
|
|
}
|
|
|
|
function nearlyEqual(left, right, tolerance = 1e-6) {
|
|
return Math.abs(Number(left) - Number(right)) <= tolerance;
|
|
}
|
|
|
|
function sqlLiteral(value) {
|
|
return `'${String(value).replaceAll("'", "''")}'`;
|
|
}
|
|
|
|
function runPSQL(query) {
|
|
return execFileSync(
|
|
'docker',
|
|
['exec', database.container, 'psql', '-U', database.user, '-d', database.name, '-At', '-F', '\t', '-c', query],
|
|
{ encoding: 'utf8' },
|
|
).trim();
|
|
}
|
|
|
|
function preflightMediaTools() {
|
|
for (const command of ['ffprobe', 'ffmpeg']) {
|
|
const result = spawnSync(command, ['-version'], { encoding: 'utf8' });
|
|
assert(result.status === 0, `${command} is required for Keling video acceptance`);
|
|
}
|
|
}
|
|
|
|
function resolvePlatform() {
|
|
const fields = runPSQL(`
|
|
SELECT id::text, name, provider, status, base_url
|
|
FROM integration_platforms
|
|
WHERE platform_key = ${sqlLiteral(platformKey)}
|
|
LIMIT 1`).split('\t');
|
|
assert(fields.length === 5 && fields[0], `Platform ${platformKey} was not found`);
|
|
assert(fields[2] === 'keling', `Platform ${platformKey} provider=${fields[2]}, expected keling`);
|
|
assert(fields[3] === 'enabled', `Platform ${platformKey} status=${fields[3]}, expected enabled`);
|
|
assert(
|
|
fields[4].replace(/\/+$/, '') === 'https://api-aigv.transtreams.com/kling/v1',
|
|
`Platform ${platformKey} base URL is not the configured TranStreams Kling endpoint`,
|
|
);
|
|
return { id: fields[0], name: fields[1], provider: fields[2], status: fields[3] };
|
|
}
|
|
|
|
function validatePlatformModels(platformId) {
|
|
const output = runPSQL(`
|
|
SELECT provider_model_name, model_name, model_alias, enabled::text, model_type::text, capabilities::text
|
|
FROM platform_models
|
|
WHERE platform_id = ${sqlLiteral(platformId)}::uuid
|
|
AND model_alias IN ('kling-o1', 'kling-3.0-omni')
|
|
ORDER BY model_alias`);
|
|
const rows = output
|
|
.split(/\r?\n/)
|
|
.filter(Boolean)
|
|
.map((line) => line.split('\t'));
|
|
const expectedModels = new Map([
|
|
['kling-o1', 'kling-video-o1'],
|
|
['kling-3.0-omni', 'kling-v3-omni'],
|
|
]);
|
|
for (const [gatewayModel, providerModel] of expectedModels) {
|
|
const row = rows.find((candidate) => candidate[2] === gatewayModel);
|
|
assert(row, `Platform ${platformKey} is missing gateway model alias ${gatewayModel}`);
|
|
assert(row[0] === providerModel, `Platform model ${gatewayModel} provider_model_name=${row[0]}, expected ${providerModel}`);
|
|
assert(row[1] === gatewayModel, `Platform model ${gatewayModel} model_name=${row[1]}, expected ${gatewayModel}`);
|
|
assert(row[3] === 'true', `Platform model ${gatewayModel} is disabled`);
|
|
const modelTypes = JSON.parse(row[4]);
|
|
const capabilities = JSON.parse(row[5]);
|
|
assert(modelTypes.includes('omni_video'), `Platform model ${gatewayModel} must include omni_video`);
|
|
const omni = capabilities.omni_video || {};
|
|
assert(Array.isArray(omni.output_resolutions), `Platform model ${gatewayModel} is missing omni_video.output_resolutions`);
|
|
assert(omni.output_resolutions.includes('720p'), `Platform model ${gatewayModel} does not advertise 720p`);
|
|
assert(omni.output_resolutions.includes('1080p'), `Platform model ${gatewayModel} does not advertise 1080p`);
|
|
const expectedOutputAudio = gatewayModel !== 'kling-o1';
|
|
assert(
|
|
omni.output_audio === expectedOutputAudio,
|
|
`Platform model ${gatewayModel} omni_video.output_audio=${omni.output_audio}, expected ${expectedOutputAudio}`,
|
|
);
|
|
}
|
|
return rows.map((row) => ({ providerModelName: row[0], modelName: row[1], modelAlias: row[2], enabled: row[3] === 'true' }));
|
|
}
|
|
|
|
function resolveGatewayAPIKey() {
|
|
if (process.env.GATEWAY_E2E_API_KEY) {
|
|
assert(process.env.GATEWAY_E2E_API_KEY_ID, 'Set GATEWAY_E2E_API_KEY_ID when GATEWAY_E2E_API_KEY is provided');
|
|
return { ...apiKeyMetadata(process.env.GATEWAY_E2E_API_KEY_ID), secret: process.env.GATEWAY_E2E_API_KEY, source: 'environment' };
|
|
}
|
|
const fields = runPSQL(`
|
|
SELECT key.id::text,
|
|
key.key_secret,
|
|
key.gateway_user_id::text,
|
|
wallet.balance::float8,
|
|
wallet.frozen_balance::float8
|
|
FROM gateway_api_keys key
|
|
JOIN gateway_wallet_accounts wallet
|
|
ON wallet.gateway_user_id = key.gateway_user_id
|
|
AND wallet.currency = 'resource'
|
|
AND wallet.status = 'active'
|
|
WHERE key.deleted_at IS NULL
|
|
AND key.status = 'active'
|
|
AND COALESCE(key.key_secret, '') <> ''
|
|
AND (key.expires_at IS NULL OR key.expires_at > now())
|
|
AND (key.scopes ? 'video' OR key.scopes ? '*' OR key.scopes ? 'all')
|
|
AND (wallet.balance - wallet.frozen_balance) > 0
|
|
ORDER BY (wallet.balance - wallet.frozen_balance) DESC, key.created_at DESC
|
|
LIMIT 1`).split('\t');
|
|
assert(fields.length === 5 && fields[0] && fields[1], 'No recoverable video-scoped Gateway API Key with positive balance was found');
|
|
return {
|
|
keyId: fields[0],
|
|
secret: fields[1],
|
|
userId: fields[2],
|
|
balance: Number(fields[3]),
|
|
frozenBalance: Number(fields[4]),
|
|
source: 'database',
|
|
};
|
|
}
|
|
|
|
function apiKeyMetadata(keyId) {
|
|
const fields = runPSQL(`
|
|
SELECT key.id::text, key.gateway_user_id::text, wallet.balance::float8, wallet.frozen_balance::float8
|
|
FROM gateway_api_keys key
|
|
JOIN gateway_wallet_accounts wallet
|
|
ON wallet.gateway_user_id = key.gateway_user_id
|
|
AND wallet.currency = 'resource'
|
|
WHERE key.id = ${sqlLiteral(keyId)}::uuid
|
|
LIMIT 1`).split('\t');
|
|
assert(fields.length === 4 && fields[0], `Gateway API Key ${keyId} was not found`);
|
|
return { keyId: fields[0], userId: fields[1], balance: Number(fields[2]), frozenBalance: Number(fields[3]) };
|
|
}
|
|
|
|
function walletState(userId) {
|
|
const fields = runPSQL(`
|
|
SELECT balance::float8, frozen_balance::float8
|
|
FROM gateway_wallet_accounts
|
|
WHERE gateway_user_id = ${sqlLiteral(userId)}::uuid
|
|
AND currency = 'resource'
|
|
LIMIT 1`).split('\t');
|
|
assert(fields.length === 2, `Wallet for Gateway user ${userId} was not found`);
|
|
return { balance: Number(fields[0]), frozenBalance: Number(fields[1]) };
|
|
}
|
|
|
|
async function gatewayRequest(path, init = {}) {
|
|
const response = await fetch(`${baseURL}${path}`, {
|
|
...init,
|
|
headers: {
|
|
Authorization: `Bearer ${authentication.secret}`,
|
|
...(init.body ? { 'Content-Type': 'application/json' } : {}),
|
|
...(init.headers || {}),
|
|
},
|
|
});
|
|
const text = await response.text();
|
|
let body = {};
|
|
try {
|
|
body = text ? JSON.parse(text) : {};
|
|
} catch {
|
|
throw new Error(`${init.method || 'GET'} ${path} returned non-JSON HTTP ${response.status}`);
|
|
}
|
|
if (!response.ok) {
|
|
const code = body.code ?? body.error?.code ?? 'unknown';
|
|
const message = body.message ?? body.error?.message ?? 'request failed';
|
|
throw new Error(`${init.method || 'GET'} ${path} failed HTTP ${response.status}, code=${code}, message=${message}`);
|
|
}
|
|
return body;
|
|
}
|
|
|
|
async function createTask(validationCase) {
|
|
let taskId = '';
|
|
if (validationCase.interface === 'kling-compatible') {
|
|
const accepted = await gatewayRequest('/v1/videos/omni-video', {
|
|
method: 'POST',
|
|
body: JSON.stringify(validationCase.request),
|
|
});
|
|
assert(accepted.code === 0, `${validationCase.name} compatibility create code=${accepted.code}`);
|
|
assert(accepted.data?.task_status === 'submitted', `${validationCase.name} was not submitted`);
|
|
taskId = accepted.data?.task_id;
|
|
} else {
|
|
const accepted = await gatewayRequest('/api/v1/videos/generations', {
|
|
method: 'POST',
|
|
headers: { 'X-Async': 'true' },
|
|
body: JSON.stringify(validationCase.request),
|
|
});
|
|
taskId = accepted.taskId || accepted.task?.id;
|
|
}
|
|
assert(taskId, `${validationCase.name} create response is missing a Gateway task ID`);
|
|
submittedTasks.push({ name: validationCase.name, taskId, model: validationCase.requestedModel, reusedExistingTask: false });
|
|
return taskId;
|
|
}
|
|
|
|
async function pollTask(validationCase, taskId) {
|
|
const startedAt = Date.now();
|
|
while (Date.now() - startedAt < taskTimeoutMs) {
|
|
if (validationCase.interface === 'kling-compatible') {
|
|
const response = await gatewayRequest(`/v1/videos/omni-video/${taskId}`);
|
|
const status = response.data?.task_status;
|
|
if (status === 'succeed') break;
|
|
if (status === 'failed') {
|
|
throw new Error(`${validationCase.name} failed, code=${response.data?.task_status_code || 'unknown'}, message=${response.data?.task_status_msg || 'unknown'}`);
|
|
}
|
|
} else {
|
|
const task = await gatewayRequest(`/api/v1/tasks/${taskId}`);
|
|
if (task.status === 'succeeded') return task;
|
|
if (task.status === 'failed' || task.status === 'cancelled') {
|
|
throw new Error(`${validationCase.name} failed, code=${task.errorCode || 'unknown'}, message=${task.errorMessage || task.error || 'unknown'}`);
|
|
}
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
|
|
}
|
|
const task = await gatewayRequest(`/api/v1/tasks/${taskId}`);
|
|
if (task.status !== 'succeeded') {
|
|
throw new Error(`${validationCase.name} timed out after ${taskTimeoutMs}ms with status=${task.status}`);
|
|
}
|
|
return task;
|
|
}
|
|
|
|
async function taskEvents(taskId) {
|
|
const response = await fetch(`${baseURL}/api/v1/tasks/${taskId}/events`, {
|
|
headers: { Authorization: `Bearer ${authentication.secret}` },
|
|
});
|
|
const text = await response.text();
|
|
assert(response.ok, `GET task events failed HTTP ${response.status}`);
|
|
return text
|
|
.split(/\r?\n\r?\n/)
|
|
.flatMap((block) => {
|
|
const data = block
|
|
.split(/\r?\n/)
|
|
.filter((line) => line.startsWith('data:'))
|
|
.map((line) => line.slice(5).trim())
|
|
.join('\n');
|
|
return data ? [JSON.parse(data)] : [];
|
|
});
|
|
}
|
|
|
|
async function taskPreprocessingLogs(taskId) {
|
|
return gatewayRequest(`/api/v1/tasks/${taskId}/param-preprocessing`);
|
|
}
|
|
|
|
function videoURLFromTask(task) {
|
|
const data = Array.isArray(task.result?.data) ? task.result.data : [];
|
|
return data.find((item) => item?.type === 'video')?.url || data.find((item) => item?.url)?.url || '';
|
|
}
|
|
|
|
async function downloadVideo(url, filePath) {
|
|
const response = await fetch(url);
|
|
assert(response.ok, `Video download failed HTTP ${response.status}`);
|
|
const bytes = Buffer.from(await response.arrayBuffer());
|
|
assert(bytes.length > 0, 'Downloaded video is empty');
|
|
await writeFile(filePath, bytes);
|
|
return bytes.length;
|
|
}
|
|
|
|
function probeVideo(filePath) {
|
|
return JSON.parse(
|
|
execFileSync('ffprobe', ['-v', 'error', '-show_streams', '-show_format', '-of', 'json', filePath], {
|
|
encoding: 'utf8',
|
|
maxBuffer: 16 * 1024 * 1024,
|
|
}),
|
|
);
|
|
}
|
|
|
|
function probeAudioVolume(filePath) {
|
|
const result = spawnSync(
|
|
'ffmpeg',
|
|
['-hide_banner', '-nostats', '-i', filePath, '-map', '0:a:0', '-af', 'volumedetect', '-f', 'null', '-'],
|
|
{ encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 },
|
|
);
|
|
assert(result.status === 0, 'ffmpeg volume analysis failed');
|
|
const diagnostics = `${result.stdout || ''}\n${result.stderr || ''}`;
|
|
const maxMatch = diagnostics.match(/max_volume:\s*(-?(?:\d+(?:\.\d+)?|inf))\s*dB/i);
|
|
const meanMatch = diagnostics.match(/mean_volume:\s*(-?(?:\d+(?:\.\d+)?|inf))\s*dB/i);
|
|
assert(maxMatch, 'ffmpeg did not report max_volume');
|
|
const maxVolumeDb = Number(maxMatch[1]);
|
|
assert(Number.isFinite(maxVolumeDb), 'Audio stream is fully silent (max_volume=-inf)');
|
|
return { maxVolumeDb, meanVolumeDb: meanMatch && Number.isFinite(Number(meanMatch[1])) ? Number(meanMatch[1]) : null };
|
|
}
|
|
|
|
function validateRequestSnapshots(task, validationCase) {
|
|
const request = task.request || {};
|
|
assert(request.model === validationCase.gatewayModel, `Task ${task.id} request.model=${request.model}, expected ${validationCase.gatewayModel}`);
|
|
assert(request.resolution === validationCase.expected.resolution, `Task ${task.id} request.resolution=${request.resolution}`);
|
|
assert(request.aspect_ratio === validationCase.request.aspect_ratio, `Task ${task.id} request.aspect_ratio=${request.aspect_ratio}`);
|
|
assert(Number(request.duration) === validationCase.expected.duration, `Task ${task.id} request.duration=${request.duration}`);
|
|
assert(request.audio === validationCase.expected.audio, `Task ${task.id} request.audio=${request.audio}`);
|
|
if (validationCase.interface === 'kling-compatible') {
|
|
assert(request._gateway_compatibility === 'keling_omni_v1', `Task ${task.id} compatibility marker is missing`);
|
|
assert(request.external_task_id === validationCase.request.external_task_id, `Task ${task.id} external_task_id was not preserved`);
|
|
}
|
|
}
|
|
|
|
function validateTaskAudit(task, events, validationCase) {
|
|
const attempts = Array.isArray(task.attempts) ? task.attempts : [];
|
|
assert(attempts.length === 1, `Task ${task.id} has ${attempts.length} attempts, expected exactly one`);
|
|
const attempt = attempts[0];
|
|
assert(attempt.status === 'succeeded', `Task ${task.id} attempt status=${attempt.status}`);
|
|
assert(attempt.platformName === platform.name, `Task ${task.id} used platform ${attempt.platformName}, expected ${platform.name}`);
|
|
assert(attempt.provider === 'keling', `Task ${task.id} used provider ${attempt.provider}, expected keling`);
|
|
assert(
|
|
attempt.providerModelName === validationCase.providerModel,
|
|
`Task ${task.id} providerModelName=${attempt.providerModelName}, expected ${validationCase.providerModel}`,
|
|
);
|
|
assert(task.remoteTaskId, `Task ${task.id} is missing remoteTaskId`);
|
|
assert(attempt.requestId, `Task ${task.id} attempt is missing requestId`);
|
|
const attemptRequest = attempt.requestSnapshot || {};
|
|
assert(attemptRequest.model === validationCase.gatewayModel, `Task ${task.id} attempt request.model=${attemptRequest.model}`);
|
|
assert(attemptRequest.resolution === validationCase.expected.resolution, `Task ${task.id} attempt request.resolution=${attemptRequest.resolution}`);
|
|
assert(attemptRequest.aspect_ratio === validationCase.request.aspect_ratio, `Task ${task.id} attempt request.aspect_ratio=${attemptRequest.aspect_ratio}`);
|
|
assert(Number(attemptRequest.duration) === validationCase.expected.duration, `Task ${task.id} attempt request.duration=${attemptRequest.duration}`);
|
|
assert(attemptRequest.audio === validationCase.expected.audio, `Task ${task.id} attempt request.audio=${attemptRequest.audio}`);
|
|
assert(Array.isArray(task.billings) && task.billings.length > 0, `Task ${task.id} has no billing lines`);
|
|
assert(Number(task.finalChargeAmount) > 0, `Task ${task.id} finalChargeAmount must be positive`);
|
|
assert(nearlyEqual(task.billingSummary?.totalAmount, task.finalChargeAmount), `Task ${task.id} billing total does not match final charge`);
|
|
const startedEvents = events.filter((event) => event.eventType === 'task.attempt.started');
|
|
assert(startedEvents.length === 1, `Task ${task.id} emitted ${startedEvents.length} task.attempt.started events`);
|
|
return attempt;
|
|
}
|
|
|
|
function inspectMedia(probe, filePath, taskId) {
|
|
const streams = Array.isArray(probe.streams) ? probe.streams : [];
|
|
const video = streams.find((stream) => stream.codec_type === 'video');
|
|
const audioStreams = streams.filter((stream) => stream.codec_type === 'audio');
|
|
assert(video, `Task ${taskId} output has no video stream`);
|
|
const width = Number(video.width);
|
|
const height = Number(video.height);
|
|
const duration = Number(video.duration || probe.format?.duration);
|
|
const shortEdge = Math.min(width, height);
|
|
const ratio = width / height;
|
|
assert(Number.isFinite(duration), `Task ${taskId} output duration is unavailable`);
|
|
const volume = audioStreams.length > 0 ? probeAudioVolume(filePath) : null;
|
|
return {
|
|
width,
|
|
height,
|
|
shortEdge,
|
|
duration,
|
|
ratio,
|
|
videoCodec: video.codec_name || null,
|
|
audioStreams: audioStreams.map((stream) => ({
|
|
codec: stream.codec_name || null,
|
|
channels: Number(stream.channels || 0),
|
|
sampleRate: Number(stream.sample_rate || 0),
|
|
})),
|
|
volume,
|
|
};
|
|
}
|
|
|
|
function validateMedia(observed, expected, taskId) {
|
|
const ratioError = Math.abs(observed.ratio - expected.ratio) / expected.ratio;
|
|
observed.ratioErrorPercent = ratioError * 100;
|
|
assert(observed.shortEdge >= expected.shortEdge, `Task ${taskId} short edge=${observed.shortEdge}, expected at least ${expected.shortEdge}`);
|
|
assert(ratioError <= 0.01, `Task ${taskId} aspect ratio error=${(ratioError * 100).toFixed(2)}%, expected <=1%`);
|
|
assert(Math.abs(observed.duration - expected.duration) <= 1, `Task ${taskId} duration=${observed.duration}s, expected ${expected.duration}s ±1s`);
|
|
if (expected.audio) {
|
|
assert(observed.audioStreams.length > 0, `Task ${taskId} requested audio but output has no audio stream`);
|
|
assert(observed.volume && Number.isFinite(observed.volume.maxVolumeDb), `Task ${taskId} audio stream is fully silent`);
|
|
} else {
|
|
assert(observed.audioStreams.length === 0, `Task ${taskId} disabled audio but output has ${observed.audioStreams.length} audio stream(s)`);
|
|
}
|
|
}
|
|
|
|
function sanitizedFailureMessage(error) {
|
|
return String(error instanceof Error ? error.message : error)
|
|
.replace(/https?:\/\/[^\s,}]+/gi, '[redacted-url]')
|
|
.replace(/Authorization:\s*Bearer\s+\S+/gi, 'Authorization: Bearer [redacted]');
|
|
}
|
|
|
|
async function writeFailureReport(error) {
|
|
const report = {
|
|
ok: false,
|
|
generatedAt: new Date().toISOString(),
|
|
baseURL,
|
|
platform: { key: platformKey, name: platform?.name || null, provider: platform?.provider || null },
|
|
authentication: authentication ? { type: 'gateway_api_key', source: authentication.source, keyId: authentication.keyId } : null,
|
|
selectedCases: validationCases.map((item) => ({ name: item.name, interface: item.interface, model: item.requestedModel })),
|
|
submittedTasks,
|
|
error: sanitizedFailureMessage(error),
|
|
};
|
|
await mkdir(dirname(outputPath), { recursive: true });
|
|
await writeFile(outputPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
|
|
return report;
|
|
}
|
|
|
|
let platform;
|
|
let authentication;
|
|
|
|
async function main() {
|
|
preflightMediaTools();
|
|
platform = resolvePlatform();
|
|
const platformModels = validatePlatformModels(platform.id);
|
|
authentication = resolveGatewayAPIKey();
|
|
const health = await fetch(`${baseURL}/healthz`);
|
|
assert(health.ok, `Gateway health check failed HTTP ${health.status}`);
|
|
|
|
const walletBefore = walletState(authentication.userId);
|
|
const tempDirectory = await mkdtemp(join(tmpdir(), 'keling-video-e2e-'));
|
|
const results = [];
|
|
try {
|
|
for (const validationCase of validationCases) {
|
|
const resumedTaskId = String(resumeTaskIds[validationCase.name] || '').trim();
|
|
let taskId;
|
|
if (resumedTaskId) {
|
|
taskId = resumedTaskId;
|
|
submittedTasks.push({
|
|
name: validationCase.name,
|
|
taskId,
|
|
model: validationCase.requestedModel,
|
|
reusedExistingTask: true,
|
|
});
|
|
console.error(`Revalidating existing task for ${validationCase.name}`);
|
|
} else {
|
|
console.error(`Submitting ${validationCase.name} exactly once`);
|
|
taskId = await createTask(validationCase);
|
|
}
|
|
const task = await pollTask(validationCase, taskId);
|
|
const [events, preprocessing] = await Promise.all([taskEvents(taskId), taskPreprocessingLogs(taskId)]);
|
|
validateRequestSnapshots(task, validationCase);
|
|
const attempt = validateTaskAudit(task, events, validationCase);
|
|
assert(Array.isArray(preprocessing.items), `Task ${taskId} preprocessing audit is unavailable`);
|
|
const videoURL = videoURLFromTask(task);
|
|
assert(videoURL, `Task ${taskId} result is missing a video URL`);
|
|
const videoPath = join(tempDirectory, `${validationCase.name}.mp4`);
|
|
const byteSize = await downloadVideo(videoURL, videoPath);
|
|
const observed = inspectMedia(probeVideo(videoPath), videoPath, taskId);
|
|
let validationError = '';
|
|
try {
|
|
validateMedia(observed, validationCase.expected, taskId);
|
|
} catch (error) {
|
|
validationError = sanitizedFailureMessage(error);
|
|
if (!continueOnValidationFailure) throw error;
|
|
}
|
|
results.push({
|
|
passed: validationError === '',
|
|
validationError: validationError || undefined,
|
|
name: validationCase.name,
|
|
interface: validationCase.interface,
|
|
taskId,
|
|
remoteTaskId: task.remoteTaskId,
|
|
requestId: attempt.requestId,
|
|
platform: { key: platformKey, name: attempt.platformName, provider: attempt.provider },
|
|
requestedModel: validationCase.requestedModel,
|
|
providerModelName: attempt.providerModelName,
|
|
reusedExistingTask: Boolean(resumedTaskId),
|
|
requested: {
|
|
resolution: validationCase.expected.resolution,
|
|
aspectRatio: validationCase.request.aspect_ratio,
|
|
duration: validationCase.expected.duration,
|
|
audio: validationCase.expected.audio,
|
|
},
|
|
observed,
|
|
byteSize,
|
|
attemptCount: task.attemptCount,
|
|
billingLineCount: task.billings.length,
|
|
finalChargeAmount: Number(task.finalChargeAmount),
|
|
billingSummary: task.billingSummary || {},
|
|
eventTypes: events.map((event) => event.eventType),
|
|
preprocessingChangeCount: preprocessing.items.reduce((sum, item) => sum + Number(item.changeCount || 0), 0),
|
|
});
|
|
}
|
|
} finally {
|
|
await rm(tempDirectory, { recursive: true, force: true });
|
|
}
|
|
|
|
const walletAfter = walletState(authentication.userId);
|
|
const totalHistoricalCharge = results.reduce((sum, result) => sum + result.finalChargeAmount, 0);
|
|
const totalChargeThisRun = results
|
|
.filter((result) => !result.reusedExistingTask)
|
|
.reduce((sum, result) => sum + result.finalChargeAmount, 0);
|
|
const walletDebit = walletBefore.balance - walletAfter.balance;
|
|
assert(nearlyEqual(walletDebit, totalChargeThisRun), `Wallet debit=${walletDebit}, expected this-run charge=${totalChargeThisRun}`);
|
|
assert(
|
|
nearlyEqual(walletAfter.frozenBalance, walletBefore.frozenBalance),
|
|
`Wallet frozen balance changed from ${walletBefore.frozenBalance} to ${walletAfter.frozenBalance}`,
|
|
);
|
|
|
|
const report = {
|
|
ok: results.every((result) => result.passed),
|
|
generatedAt: new Date().toISOString(),
|
|
baseURL,
|
|
platform: { key: platformKey, name: platform.name, provider: platform.provider },
|
|
platformModels,
|
|
authentication: { type: 'gateway_api_key', source: authentication.source, keyId: authentication.keyId },
|
|
wallet: {
|
|
balanceBefore: walletBefore.balance,
|
|
balanceAfter: walletAfter.balance,
|
|
frozenBalanceBefore: walletBefore.frozenBalance,
|
|
frozenBalanceAfter: walletAfter.frozenBalance,
|
|
debit: walletDebit,
|
|
totalChargeThisRun,
|
|
totalHistoricalCharge,
|
|
},
|
|
results,
|
|
};
|
|
await mkdir(dirname(outputPath), { recursive: true });
|
|
await writeFile(outputPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
|
|
console.log(JSON.stringify({ ...report, outputPath }, null, 2));
|
|
if (!report.ok) process.exitCode = 1;
|
|
}
|
|
|
|
main().catch(async (error) => {
|
|
const report = await writeFailureReport(error);
|
|
console.error(report.error);
|
|
console.error(`Failure report: ${outputPath}`);
|
|
process.exitCode = 1;
|
|
});
|