Files
shumai/packages/e2e/workflow/transcode-video.test.ts
T
Yiling-J 20b5ebeefd fix(asset): mark asset as failed and display failure state in webui when transcoding fails (#445)
* fix(asset): mark asset as failed and display failure state in webui when transcoding fails

* fix(transcode): do not mark asset as failed if media processing already succeeded

* test(workflow): add e2e test for video transcode failure status transition

* fix(webui): update failed file card badge to top-right Transcoding Failed label with error tooltip
2026-10-02 20:09:32 +08:00

1182 lines
35 KiB
TypeScript

import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest'
import { prisma, AssetStatus, AssetType } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { workflowService, TaskQueueTranscode } from '@shumai/workflow-core'
import { initTranscodeWorkflows } from '@shumai/transcode'
import { s3Service } from '@shumai/core/src/s3/s3'
import { assetService } from '@shumai/core/src/asset/asset'
import { fileURLToPath } from 'url'
import * as path from 'path'
import * as fs from 'fs'
import * as os from 'os'
import { execFile } from 'child_process'
import { promisify } from 'util'
const execFileAsync = promisify(execFile)
const currentDir = path.dirname(fileURLToPath(import.meta.url))
const transcodeWorkflowsPath = path.resolve(currentDir, '../../../apps/transcode/src/workflows.ts')
const fixturesDir = path.resolve(currentDir, '../fixtures')
async function sampleFirstFrameRgb(
buffer: Buffer,
ext: string = 'mp4',
): Promise<{ r: number; g: number; b: number }> {
const tmpFile = path.join(
os.tmpdir(),
`sample-${Date.now()}-${Math.random().toString(36).slice(2)}.${ext}`,
)
try {
fs.writeFileSync(tmpFile, buffer)
const proc = await execFileAsync(
'ffmpeg',
[
'-y',
'-i',
tmpFile,
'-vframes',
'1',
'-s',
'1x1',
'-f',
'rawvideo',
'-pix_fmt',
'rgb24',
'pipe:1',
],
{ encoding: 'buffer' },
)
return {
r: proc.stdout[0],
g: proc.stdout[1],
b: proc.stdout[2],
}
} finally {
if (fs.existsSync(tmpFile)) {
fs.unlinkSync(tmpFile)
}
}
}
describe.each(['local', 'temporal'] as const)(
'Workflow E2E - transcodeVideoWorkflow (executor: %s)',
(mode) => {
setupTestDbHooks()
let transcodeWorkerPromise: Promise<void> | null = null
beforeAll(async () => {
process.env.S3_BUCKET = 'shumai-e2e-test-bucket-transcode'
workflowService.setExecutorType(mode)
initTranscodeWorkflows()
if (mode === 'temporal') {
console.log('Starting background worker for transcode Temporal E2E tests...')
transcodeWorkerPromise = workflowService.startWorkers(TaskQueueTranscode, {
workflowsPath: transcodeWorkflowsPath,
})
await new Promise((resolve) => setTimeout(resolve, 2000))
} else {
console.log('Starting local workflow service polling...')
workflowService.start()
}
})
afterAll(async () => {
if (mode === 'temporal') {
console.log('Shutting down Temporal workers...')
await workflowService.shutdownWorkers()
await Promise.all([transcodeWorkerPromise].filter(Boolean))
}
workflowService.close()
vi.restoreAllMocks()
try {
console.log('Cleaning up local E2E storage files...')
await s3Service.deletePrefix('shumai-e2e-test-bucket-transcode', '')
} catch (err) {
console.error('Failed to clean up E2E storage folder:', err)
}
})
it('should run transcodeMedia workflow for a video asset successfully', async () => {
// 1. Seed Database
const team = await prisma.team.create({
data: { name: 'E2E Video Transcode Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Video Transcode Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: {
key: 'projects/e2e/video-trans.mp4',
},
})
const asset = await prisma.asset.create({
data: {
name: 'video-trans.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
// 2. Seed S3 Storage from Fixture
const mp4Path = path.join(fixturesDir, 'small.mp4')
const mp4Buffer = fs.readFileSync(mp4Path)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/video-trans.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
// 3. Create Workflow Task
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
thumbnail: false,
poster: true,
sprite: true,
},
},
},
})
// 4. Wait for workflow to complete
console.log(
`Submitted E2E Video Transcode Workflow Task. ID: ${task.id}. Awaiting completion...`,
)
const completedTask = await workflowService.executeWait(task, 45000)
// 5. Verification
expect(completedTask.status).toBe('completed')
// Verify Asset status is updated to processed
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
// Verify media info contains videoTranscodes, poster, sprite, and duration details
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
duration: number
videoTranscodes: { key: string }[]
poster: unknown
sprite: unknown
}
expect(mediaInfo).toBeDefined()
expect(mediaInfo.proxyType).toBe('video')
expect(mediaInfo.duration).toBeCloseTo(1.0, 1)
expect(mediaInfo.videoTranscodes).toBeDefined()
expect(mediaInfo.videoTranscodes.length).toBeGreaterThan(0)
expect(mediaInfo.poster).toBeDefined()
expect(mediaInfo.sprite).toBeDefined()
}, 50000)
it('should run transcodeMedia workflow for an audio asset successfully', async () => {
// 1. Seed Database
const team = await prisma.team.create({
data: { name: 'E2E Audio Transcode Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Audio Transcode Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: {
key: 'projects/e2e/audio-trans.wav',
},
})
const asset = await prisma.asset.create({
data: {
name: 'audio-trans.wav',
type: 'file',
status: 'uploaded',
mediaType: 'audio/wav',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
// 2. Seed S3 Storage from Fixture
const wavPath = path.join(fixturesDir, 'small.wav')
const wavBuffer = fs.readFileSync(wavPath)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/audio-trans.wav',
wavBuffer,
wavBuffer.length,
'audio/wav',
)
// 3. Create Workflow Task
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {},
},
},
})
// 4. Wait for workflow to complete
console.log(
`Submitted E2E Audio Transcode Workflow Task. ID: ${task.id}. Awaiting completion...`,
)
const completedTask = await workflowService.executeWait(task, 45000)
// 5. Verification
expect(completedTask.status).toBe('completed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
videoTranscodes: { key: string }[]
}
expect(mediaInfo).toBeDefined()
expect(mediaInfo.proxyType).toBe('audio')
expect(mediaInfo.videoTranscodes).toBeDefined()
expect(mediaInfo.videoTranscodes.length).toBeGreaterThan(0)
// Audio proxy key should end with -audio-proxy.mp4
expect(mediaInfo.videoTranscodes[0].key).toContain('-audio-proxy.mp4')
}, 50000)
it('should run transcodeMedia workflow with HLS enabled and serve playlists for version stacks and symlinks', async () => {
// 1. Seed Database
const team = await prisma.team.create({
data: {
name: 'E2E HLS Video Transcode Team',
settings: {
transcode: {
videoStrategy: 'best_match',
hlsEnabled: true,
hlsResolutions: ['480p'],
},
},
},
})
const project = await prisma.project.create({
data: { name: 'E2E HLS Video Transcode Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: {
key: 'projects/e2e/video-hls.mp4',
},
})
const asset = await prisma.asset.create({
data: {
name: 'video-hls.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
// 2. Seed S3 Storage from Fixture (small-480p.mp4)
const mp4Path = path.join(fixturesDir, 'small-480p.mp4')
const mp4Buffer = fs.readFileSync(mp4Path)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/video-hls.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
// 3. Create Workflow Task
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
hlsEnabled: true,
hlsResolutions: ['480p'],
},
},
},
})
// 4. Wait for workflow to complete
console.log(
`Submitted E2E HLS Transcode Workflow Task. ID: ${task.id}. Awaiting completion...`,
)
const completedTask = await workflowService.executeWait(task, 45000)
expect(completedTask.status).toBe('completed')
// 5. Verification of HLS generation
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as PrismaJson.MediaInfo
expect(mediaInfo.isHls).toBe(true)
expect(mediaInfo.hls).toBeDefined()
expect(mediaInfo.hls?.key).toBe('projects/e2e/hls/master.m3u8')
expect(mediaInfo.hls?.resolutions).toBeDefined()
expect(mediaInfo.hls?.resolutions?.length).toBeGreaterThan(0)
expect(mediaInfo.hls?.resolutions?.[0]?.resolution).toBe('480p')
// Verify master playlist in S3
const masterObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/hls/master.m3u8',
)
const masterPlaylist = masterObj.buffer.toString('utf-8')
expect(masterPlaylist).toContain('#EXTM3U')
expect(masterPlaylist).toContain('480p/index.m3u8')
// Verify variant playlist in S3
const variantObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/hls/480p/index.m3u8',
)
expect(variantObj.buffer.toString('utf-8')).toContain('#EXTM3U')
// 6. Test Version Stack & Symlink Resolution
const stack = await prisma.asset.create({
data: {
name: 'video-hls-stack',
type: AssetType.version_stack,
status: AssetStatus.processed,
projectId: project.id,
},
})
await prisma.asset.update({
where: { id: asset.id },
data: {
parentId: stack.id,
sortIndex: 'a',
},
})
const symlink = await prisma.asset.create({
data: {
name: 'video-hls-symlink',
type: AssetType.symlink,
status: AssetStatus.processed,
projectId: project.id,
targetId: stack.id,
},
})
// Calling getHlsMasterPlaylist with stack ID
const stackMaster = await assetService.getHlsMasterPlaylist({ assetId: stack.id })
expect(stackMaster).toContain('#EXTM3U')
expect(stackMaster).toContain('480p/index.m3u8')
// Calling getHlsMasterPlaylist with symlink ID
const symlinkMaster = await assetService.getHlsMasterPlaylist({ assetId: symlink.id })
expect(symlinkMaster).toContain('#EXTM3U')
expect(symlinkMaster).toContain('480p/index.m3u8')
// Calling getHlsVariantPlaylist with symlink ID
const symlinkVariant = await assetService.getHlsVariantPlaylist({
assetId: symlink.id,
resolution: '480p',
})
expect(symlinkVariant).toContain('#EXTM3U')
}, 60000)
it('Case 1: should ignore attached picture cover art (Red) and select primary video stream (Green)', async () => {
const team = await prisma.team.create({
data: { name: 'E2E Cover Art Video Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Cover Art Video Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: { key: 'projects/e2e/case1/video.mp4' },
})
const asset = await prisma.asset.create({
data: {
name: 'video.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'e2e-case1-'))
const videoPath = path.join(tmpDir, 'case1.mp4')
try {
await execFileAsync('ffmpeg', [
'-y',
'-f',
'lavfi',
'-i',
'color=c=green:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'color=c=red:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'sine=f=1000:d=2',
'-map',
'0:v',
'-map',
'1:v',
'-map',
'2:a',
'-c:v:0',
'libx264',
'-pix_fmt:v:0',
'yuv420p',
'-c:v:1',
'mjpeg',
'-pix_fmt:v:1',
'yuvj420p',
'-c:a',
'aac',
'-disposition:v:1',
'attached_pic',
videoPath,
])
const mp4Buffer = fs.readFileSync(videoPath)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/case1/video.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true })
}
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
poster: true,
sprite: true,
},
},
},
})
const completedTask = await workflowService.executeWait(task, 45000)
expect(completedTask.status).toBe('completed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
metadata: { videoStreamIndex: number }
poster: { key: string }
sprite: { key: string }
videoTranscodes: { key: string }[]
}
expect(mediaInfo.proxyType).toBe('video')
expect(mediaInfo.metadata.videoStreamIndex).toBe(0)
// Verify poster is Green (not Red attached pic)
expect(mediaInfo.poster?.key).toBeDefined()
const posterObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.poster.key,
)
const posterColor = await sampleFirstFrameRgb(posterObj.buffer, 'webp')
expect(posterColor.g).toBeGreaterThan(100)
expect(posterColor.r).toBeLessThan(50)
expect(posterColor.b).toBeLessThan(50)
// Verify MP4 proxy is Green
expect(mediaInfo.videoTranscodes.length).toBeGreaterThan(0)
const videoObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.videoTranscodes[0].key,
)
const videoColor = await sampleFirstFrameRgb(videoObj.buffer, 'mp4')
expect(videoColor.g).toBeGreaterThan(100)
expect(videoColor.r).toBeLessThan(50)
expect(videoColor.b).toBeLessThan(50)
// Verify sprite sheet exists
expect(mediaInfo.sprite?.key).toBeDefined()
await s3Service.headObject('shumai-e2e-test-bucket-transcode', mediaInfo.sprite.key)
}, 60000)
it('Case 2: should select higher bitrate stream (Blue) when both streams have default flag', async () => {
const team = await prisma.team.create({
data: { name: 'E2E Bitrate Comparison Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Bitrate Comparison Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: { key: 'projects/e2e/case2/video.mp4' },
})
const asset = await prisma.asset.create({
data: {
name: 'video.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'e2e-case2-'))
const videoPath = path.join(tmpDir, 'case2.mp4')
try {
await execFileAsync('ffmpeg', [
'-y',
'-f',
'lavfi',
'-i',
'color=c=red:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'color=c=blue:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'sine=f=1000:d=2',
'-map',
'0:v',
'-map',
'1:v',
'-map',
'2:a',
'-c:v:0',
'libx264',
'-b:v:0',
'200k',
'-minrate:v:0',
'200k',
'-maxrate:v:0',
'200k',
'-bufsize:v:0',
'200k',
'-nal-hrd',
'cbr',
'-disposition:v:0',
'default',
'-c:v:1',
'libx264',
'-b:v:1',
'2000k',
'-minrate:v:1',
'2000k',
'-maxrate:v:1',
'2000k',
'-bufsize:v:1',
'2000k',
'-nal-hrd',
'cbr',
'-disposition:v:1',
'default',
'-c:a',
'aac',
videoPath,
])
const mp4Buffer = fs.readFileSync(videoPath)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/case2/video.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true })
}
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
poster: true,
},
},
},
})
const completedTask = await workflowService.executeWait(task, 45000)
expect(completedTask.status).toBe('completed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
metadata: { videoStreamIndex: number }
poster: { key: string }
videoTranscodes: { key: string }[]
}
expect(mediaInfo.proxyType).toBe('video')
// Stream 1 (Blue, 2000k) should be selected over Stream 0 (Red, 200k)
expect(mediaInfo.metadata.videoStreamIndex).toBe(1)
const posterObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.poster.key,
)
const posterColor = await sampleFirstFrameRgb(posterObj.buffer, 'webp')
expect(posterColor.b).toBeGreaterThan(100)
expect(posterColor.r).toBeLessThan(50)
expect(posterColor.g).toBeLessThan(50)
const videoObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.videoTranscodes[0].key,
)
const videoColor = await sampleFirstFrameRgb(videoObj.buffer, 'mp4')
expect(videoColor.b).toBeGreaterThan(100)
expect(videoColor.r).toBeLessThan(50)
expect(videoColor.g).toBeLessThan(50)
}, 60000)
it('Case 3: should select stream with default flag (Yellow) over higher bitrate stream without default flag (Blue)', async () => {
const team = await prisma.team.create({
data: { name: 'E2E Default Flag Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Default Flag Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: { key: 'projects/e2e/case3/video.mp4' },
})
const asset = await prisma.asset.create({
data: {
name: 'video.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'e2e-case3-'))
const videoPath = path.join(tmpDir, 'case3.mp4')
try {
await execFileAsync('ffmpeg', [
'-y',
'-f',
'lavfi',
'-i',
'color=c=yellow:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'color=c=blue:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'sine=f=1000:d=2',
'-map',
'0:v',
'-map',
'1:v',
'-map',
'2:a',
'-c:v:0',
'libx264',
'-b:v:0',
'200k',
'-minrate:v:0',
'200k',
'-maxrate:v:0',
'200k',
'-bufsize:v:0',
'200k',
'-nal-hrd',
'cbr',
'-disposition:v:0',
'default',
'-c:v:1',
'libx264',
'-b:v:1',
'2000k',
'-minrate:v:1',
'2000k',
'-maxrate:v:1',
'2000k',
'-bufsize:v:1',
'2000k',
'-nal-hrd',
'cbr',
'-disposition:v:1',
'0',
'-c:a',
'aac',
videoPath,
])
const mp4Buffer = fs.readFileSync(videoPath)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/case3/video.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true })
}
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
poster: true,
},
},
},
})
const completedTask = await workflowService.executeWait(task, 45000)
expect(completedTask.status).toBe('completed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
metadata: { videoStreamIndex: number }
poster: { key: string }
videoTranscodes: { key: string }[]
}
expect(mediaInfo.proxyType).toBe('video')
// Stream 0 (Yellow, default: 1) should win over Stream 1 (Blue, 10x higher bitrate but default: 0)
expect(mediaInfo.metadata.videoStreamIndex).toBe(0)
const posterObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.poster.key,
)
const posterColor = await sampleFirstFrameRgb(posterObj.buffer, 'webp')
expect(posterColor.r).toBeGreaterThan(100)
expect(posterColor.g).toBeGreaterThan(100)
expect(posterColor.b).toBeLessThan(50)
const videoObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.videoTranscodes[0].key,
)
const videoColor = await sampleFirstFrameRgb(videoObj.buffer, 'mp4')
expect(videoColor.r).toBeGreaterThan(100)
expect(videoColor.g).toBeGreaterThan(100)
expect(videoColor.b).toBeLessThan(50)
}, 60000)
it('Case 4: should handle audio-only MP4 with cover art by downgrading to audio proxy (catches audio bug)', async () => {
const team = await prisma.team.create({
data: { name: 'E2E Audio Cover Art Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Audio Cover Art Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: { key: 'projects/e2e/case4/audio-cover.mp4' },
})
// Uploaded as video/mp4 because of .mp4 container, even though it only has audio + cover art
const asset = await prisma.asset.create({
data: {
name: 'audio-cover.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'e2e-case4-'))
const videoPath = path.join(tmpDir, 'case4.mp4')
try {
await execFileAsync('ffmpeg', [
'-y',
'-f',
'lavfi',
'-i',
'sine=f=1000:d=2',
'-f',
'lavfi',
'-i',
'color=c=magenta:s=320x240:d=2',
'-map',
'0:a',
'-map',
'1:v',
'-c:a',
'aac',
'-c:v',
'mjpeg',
'-pix_fmt:v:0',
'yuvj420p',
'-disposition:v:0',
'attached_pic',
videoPath,
])
const mp4Buffer = fs.readFileSync(videoPath)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/case4/audio-cover.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true })
}
// Spec requested poster, sprite, videoStrategy as video upload would
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
poster: true,
sprite: true,
},
},
},
})
const completedTask = await workflowService.executeWait(task, 45000)
// Must complete without error (previously failed trying to generate poster/sprite for audio)
expect(completedTask.status).toBe('completed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
poster?: unknown
sprite?: unknown
videoTranscodes: { key: string }[]
}
expect(mediaInfo.proxyType).toBe('audio')
expect(mediaInfo.poster).toBeUndefined()
expect(mediaInfo.sprite).toBeUndefined()
expect(mediaInfo.videoTranscodes.length).toBeGreaterThan(0)
expect(mediaInfo.videoTranscodes[0].key).toContain('-audio-proxy.mp4')
await s3Service.headObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.videoTranscodes[0].key,
)
}, 60000)
it('Case 5: should rank 3 video streams with HLS enabled and select highest bitrate stream (Blue)', async () => {
const team = await prisma.team.create({
data: {
name: 'E2E Multi Stream HLS Team',
settings: {
transcode: {
videoStrategy: 'best_match',
hlsEnabled: true,
hlsResolutions: ['480p'],
},
},
},
})
const project = await prisma.project.create({
data: { name: 'E2E Multi Stream HLS Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: { key: 'projects/e2e/case5/video.mp4' },
})
const asset = await prisma.asset.create({
data: {
name: 'video.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'e2e-case5-'))
const videoPath = path.join(tmpDir, 'case5.mp4')
try {
await execFileAsync('ffmpeg', [
'-y',
'-f',
'lavfi',
'-i',
'color=c=red:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'color=c=green:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'color=c=blue:s=320x240:d=2',
'-f',
'lavfi',
'-i',
'sine=f=1000:d=2',
'-map',
'0:v',
'-map',
'1:v',
'-map',
'2:v',
'-map',
'3:a',
'-c:v:0',
'libx264',
'-b:v:0',
'100k',
'-minrate:v:0',
'100k',
'-maxrate:v:0',
'100k',
'-bufsize:v:0',
'100k',
'-nal-hrd',
'cbr',
'-disposition:v:0',
'default',
'-c:v:1',
'libx264',
'-b:v:1',
'500k',
'-minrate:v:1',
'500k',
'-maxrate:v:1',
'500k',
'-bufsize:v:1',
'500k',
'-nal-hrd',
'cbr',
'-disposition:v:1',
'default',
'-c:v:2',
'libx264',
'-b:v:2',
'1500k',
'-minrate:v:2',
'1500k',
'-maxrate:v:2',
'1500k',
'-bufsize:v:2',
'1500k',
'-nal-hrd',
'cbr',
'-disposition:v:2',
'default',
'-c:a',
'aac',
videoPath,
])
const mp4Buffer = fs.readFileSync(videoPath)
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/case5/video.mp4',
mp4Buffer,
mp4Buffer.length,
'video/mp4',
)
} finally {
fs.rmSync(tmpDir, { recursive: true, force: true })
}
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
hlsEnabled: true,
hlsResolutions: ['480p'],
poster: true,
},
},
},
})
const completedTask = await workflowService.executeWait(task, 45000)
expect(completedTask.status).toBe('completed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const mediaInfo = updatedAsset?.media as unknown as {
proxyType: string
metadata: { videoStreamIndex: number }
poster: { key: string }
isHls: boolean
hls: { key: string; resolutions: { resolution: string }[] }
}
expect(mediaInfo.proxyType).toBe('video')
// Stream 2 (Blue, 1500k) should be selected
expect(mediaInfo.metadata.videoStreamIndex).toBe(2)
const posterObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.poster.key,
)
const posterColor = await sampleFirstFrameRgb(posterObj.buffer, 'webp')
expect(posterColor.b).toBeGreaterThan(100)
expect(posterColor.r).toBeLessThan(50)
expect(posterColor.g).toBeLessThan(50)
expect(mediaInfo.isHls).toBe(true)
const masterObj = await s3Service.getObject(
'shumai-e2e-test-bucket-transcode',
mediaInfo.hls.key,
)
expect(masterObj.buffer.toString('utf-8')).toContain('480p/index.m3u8')
}, 60000)
it('should transition both task and asset to failed status with media.error when transcoding fails', async () => {
const team = await prisma.team.create({
data: { name: 'E2E Failed Transcode Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Failed Transcode Project', teamId: team.id },
})
const storageKey = await prisma.storageKey.create({
data: { key: 'projects/e2e/corrupt-video.mp4' },
})
const asset = await prisma.asset.create({
data: {
name: 'corrupt-video.mp4',
type: 'file',
status: 'uploaded',
mediaType: 'video/mp4',
projectId: project.id,
storageKeyId: storageKey.id,
},
})
const corruptBuffer = Buffer.from('not a valid mp4 media stream at all')
await s3Service.putObject(
'shumai-e2e-test-bucket-transcode',
'projects/e2e/corrupt-video.mp4',
corruptBuffer,
corruptBuffer.length,
'video/mp4',
)
const task = await prisma.workflowTask.create({
data: {
type: 'transcode_video',
status: 'pending',
assetId: asset.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
transcode: {
videoStrategy: 'best_match',
},
},
},
})
await expect(workflowService.executeWait(task, 45000)).rejects.toThrow()
const failedTask = await prisma.workflowTask.findUnique({
where: { id: task.id },
})
expect(failedTask?.status).toBe('failed')
const updatedAsset = await prisma.asset.findUnique({
where: { id: asset.id },
})
expect(updatedAsset?.status).toBe(AssetStatus.failed)
const media = updatedAsset?.media as PrismaJson.MediaInfo
expect(media?.error).toBeDefined()
expect(media?.error?.length).toBeGreaterThan(0)
}, 45000)
},
)