Files
shumai/packages/transcode/src/activities/transcode.test.ts
T

955 lines
31 KiB
TypeScript
Raw Normal View History

2026-06-07 19:25:47 +08:00
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { s3Service } from '@shumai/core/src/s3/s3'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
2026-06-07 19:25:47 +08:00
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { gotenbergService } from '@shumai/core/src/gotenberg/gotenberg'
import { transcodeService } from '@shumai/core/src/transcode/transcode'
import * as child_process from 'child_process'
vi.mock('child_process', () => ({
execFile: vi.fn(),
}))
import {
getMediaInfoActivity,
2026-06-07 19:25:47 +08:00
overlayAnnotationsActivity,
renderPdfPagesActivity,
2026-06-07 19:25:47 +08:00
takeScreenshotsActivity,
transcodeVideoActivity,
transcodeAudioActivity,
updateAssetMediaActivity,
downloadMediaToTmpActivity,
transcodeImageActivity,
generateSpriteActivity,
generatePdfProxyActivity,
transcodeVideoChunkActivity,
deleteS3ObjectActivity,
createAutofillTaskIfEnabledActivity,
} from './transcode'
2026-05-19 16:05:09 +08:00
vi.mock('@shumai/core/src/s3/s3', () => ({
2026-05-19 16:05:09 +08:00
s3Service: {
getObject: vi.fn(),
putObject: vi.fn(),
headObject: vi.fn(),
presign: vi.fn(),
downloadToFile: vi.fn(),
deleteObject: vi.fn(),
2026-05-19 16:05:09 +08:00
},
}))
vi.mock('@shumai/core/src/transcode/transcode', async (importOriginal) => {
const actual = await importOriginal<typeof import('@shumai/core/src/transcode/transcode')>()
return {
...actual,
transcodeService: {
getVideoInfo: vi.fn(),
getAudioInfo: vi.fn(),
getImageInfo: vi.fn(),
getPdfInfo: vi.fn().mockResolvedValue({
originalWidth: 800,
originalHeight: 1000,
duration: 0,
bitRate: 0,
frameRate: 0,
totalFrames: 10,
hasAudio: false,
mimeType: 'application/pdf',
}),
transcodeVideo: vi.fn(),
transcodeAudio: vi.fn(),
transcodeImage: vi.fn(),
generateSprite: vi.fn(),
generatePdfSprite: vi.fn().mockResolvedValue({
pageCount: 10,
originalWidth: 800,
originalHeight: 1000,
}),
generatePdfFromText: vi.fn(),
generatePdfFromCsv: vi.fn(),
createTempDir: vi.fn().mockReturnValue('/tmp'),
removeDir: vi.fn(),
takeScreenshots: vi.fn(),
overlayAnnotations: vi.fn(),
renderPdfPages: vi.fn(),
},
}
})
2026-05-19 16:05:09 +08:00
vi.mock('@shumai/core/src/metadata/metadata', () => ({
metadataService: {
updateAssetMetadata: vi.fn(),
},
}))
2026-05-19 16:05:09 +08:00
vi.mock('fs', async (importOriginal) => {
const actual = await importOriginal<typeof import('fs')>()
return {
...actual,
readFileSync: vi.fn().mockReturnValue(Buffer.from('fake data')),
statSync: vi.fn().mockReturnValue({ size: 9 }),
existsSync: vi.fn().mockReturnValue(true),
mkdirSync: vi.fn(),
unlinkSync: vi.fn(),
2026-05-19 16:05:09 +08:00
}
})
describe('Transcode Activities', () => {
setupTestDbHooks()
beforeEach(async () => {
2026-05-19 16:05:09 +08:00
vi.clearAllMocks()
const fs = await import('fs')
vi.mocked(fs.readFileSync).mockImplementation(() => Buffer.from('fake data') as never)
})
it('should convert CSV via Gotenberg in landscape mode when maxCols > 5', async () => {
const asset = await prisma.asset.create({
data: { name: 'wide.csv', type: 'file', status: 'uploaded' },
})
const fs = await import('fs')
vi.mocked(fs.readFileSync).mockImplementation((_path: unknown, options?: unknown) => {
if (options) {
return 'c1,c2,c3,c4,c5,c6,c7\n1,2,3,4,5,6,7' as never
}
return Buffer.from('fake data') as never
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const convertSpy = vi
.spyOn(gotenbergService, 'convertDocumentToPdf')
.mockResolvedValue(Buffer.from('fake pdf landscape csv'))
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/wide.csv',
filePath: '/tmp/wide.csv',
mediaType: 'text/csv',
filename: 'wide.csv',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(convertSpy).toHaveBeenCalledWith('/tmp/wide.csv', 'wide.csv', { landscape: true })
vi.mocked(fs.readFileSync).mockImplementation(() => Buffer.from('fake data') as never)
})
it('should convert CSV via Gotenberg in portrait mode when maxCols <= 5', async () => {
const asset = await prisma.asset.create({
data: { name: 'narrow.csv', type: 'file', status: 'uploaded' },
})
const fs = await import('fs')
vi.mocked(fs.readFileSync).mockImplementation((_path: unknown, options?: unknown) => {
if (options) {
return 'c1,c2,c3\n1,2,3' as never
}
return Buffer.from('fake data') as never
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const convertSpy = vi
.spyOn(gotenbergService, 'convertDocumentToPdf')
.mockResolvedValue(Buffer.from('fake pdf portrait csv'))
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/narrow.csv',
filePath: '/tmp/narrow.csv',
mediaType: 'text/csv',
filename: 'narrow.csv',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(convertSpy).toHaveBeenCalledWith('/tmp/narrow.csv', 'narrow.csv', { landscape: false })
vi.mocked(fs.readFileSync).mockImplementation(() => Buffer.from('fake data') as never)
2026-05-19 16:05:09 +08:00
})
it('should call getVideoInfo and set file_type to video', async () => {
2026-05-19 16:05:09 +08:00
const asset = await prisma.asset.create({
data: { name: 'v.mp4', type: 'file', status: 'uploaded' },
})
vi.mocked(transcodeService.getVideoInfo).mockResolvedValue({
originalWidth: 1920,
originalHeight: 1080,
duration: 10,
bitRate: 1000,
videoBitRate: 850000,
2026-05-19 16:05:09 +08:00
frameRate: 30,
totalFrames: 300,
2026-05-19 16:05:09 +08:00
hasAudio: true,
videoCodec: 'Advanced Video Coding',
audioCodec: 'MPEG-4 Audio',
audioChannels: 2,
audioSampleRate: 48000,
audioBitDepth: 16,
2026-05-19 16:05:09 +08:00
mimeType: 'video/mp4',
})
const result = await getMediaInfoActivity({
assetId: asset.id,
filePath: '/tmp/v.mp4',
proxyType: 'video',
2026-05-19 16:05:09 +08:00
mediaType: 'video/mp4',
})
expect(transcodeService.getVideoInfo).toHaveBeenCalledWith('/tmp/v.mp4')
expect(result.duration).toBe(10)
2026-06-07 19:25:47 +08:00
expect(result.metadata?.originalWidth).toBe(1920)
expect(result.metadata?.videoBitRate).toBe(850000)
2026-06-07 19:25:47 +08:00
expect(result.metadata?.videoCodec).toBe('Advanced Video Coding')
expect(result.metadata?.audioCodec).toBe('MPEG-4 Audio')
expect(result.metadata?.audioChannels).toBe(2)
expect(result.metadata?.audioSampleRate).toBe(48000)
expect(result.metadata?.audioBitDepth).toBe(16)
expect(metadataService.updateAssetMetadata).toHaveBeenCalledWith(
asset.id,
expect.arrayContaining([{ key: 'file_type', value: 'video' }]),
true,
)
2026-05-19 16:05:09 +08:00
})
it('should call getImageInfo and set file_type to image', async () => {
2026-05-19 16:05:09 +08:00
const asset = await prisma.asset.create({
data: { name: 'i.png', type: 'file', status: 'uploaded' },
})
vi.mocked(transcodeService.getImageInfo).mockResolvedValue({
originalWidth: 800,
originalHeight: 600,
duration: 0,
bitRate: 0,
frameRate: 0,
totalFrames: 0,
2026-05-19 16:05:09 +08:00
hasAudio: false,
mimeType: 'image/png',
})
2026-06-07 19:25:47 +08:00
const result = await getMediaInfoActivity({
2026-05-19 16:05:09 +08:00
assetId: asset.id,
filePath: '/tmp/i.png',
proxyType: 'image',
2026-05-19 16:05:09 +08:00
mediaType: 'image/png',
})
expect(transcodeService.getImageInfo).toHaveBeenCalledWith('/tmp/i.png')
2026-06-07 19:25:47 +08:00
expect(result.metadata?.originalWidth).toBe(800)
expect(result.metadata?.duration).toBe(0)
expect(metadataService.updateAssetMetadata).toHaveBeenCalledWith(
asset.id,
expect.arrayContaining([{ key: 'file_type', value: 'image' }]),
true,
)
})
it('should set file_type to audio for audio files and extract audio metadata', async () => {
const asset = await prisma.asset.create({
data: { name: 'a.mp3', type: 'file', status: 'uploaded' },
})
vi.mocked(transcodeService.getAudioInfo).mockResolvedValue({
originalWidth: 0,
originalHeight: 0,
duration: 45.5,
bitRate: 128000,
frameRate: 0,
totalFrames: 0,
hasAudio: true,
audioCodec: 'mp3',
audioChannels: 2,
audioSampleRate: 44100,
audioBitDepth: 16,
mimeType: 'audio/mpeg',
})
const result = await getMediaInfoActivity({
assetId: asset.id,
filePath: '/tmp/a.mp3',
proxyType: 'audio',
mediaType: 'audio/mpeg',
})
expect(transcodeService.getAudioInfo).toHaveBeenCalledWith('/tmp/a.mp3')
expect(result.duration).toBe(45.5)
expect(result.metadata?.duration).toBe(45.5)
expect(result.metadata?.audioCodec).toBe('mp3')
expect(result.metadata?.audioChannels).toBe(2)
expect(result.metadata?.audioSampleRate).toBe(44100)
expect(result.metadata?.audioBitDepth).toBe(16)
expect(metadataService.updateAssetMetadata).toHaveBeenCalledWith(
asset.id,
expect.arrayContaining([
{ key: 'file_type', value: 'audio' },
{ key: 'duration', value: 45.5 },
{ key: 'audio_codec', value: 'mp3' },
{ key: 'audio_channels', value: 2 },
{ key: 'audio_sample_rate', value: 44100 },
{ key: 'audio_bit_depth', value: 16 },
]),
true,
)
})
it('should set file_type to document for pdf/text files', async () => {
const asset = await prisma.asset.create({
data: { name: 'd.pdf', type: 'file', status: 'uploaded' },
})
await getMediaInfoActivity({
assetId: asset.id,
filePath: '/tmp/d.pdf',
proxyType: 'pdf',
mediaType: 'application/pdf',
})
expect(metadataService.updateAssetMetadata).toHaveBeenCalledWith(
asset.id,
expect.arrayContaining([
{ key: 'file_type', value: 'document' },
{ key: 'proxy_type', value: 'pdf' },
]),
true,
)
})
it('should generate PDF proxy for text/csv files in generatePdfProxyActivity', async () => {
const asset = await prisma.asset.create({
data: { name: 'test.txt', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
const generatePdfFromTextSpy = vi
.spyOn(transcodeService, 'generatePdfFromText')
.mockImplementation(async (_inPath, outPath) => {
const fs = await import('fs')
fs.writeFileSync(outPath, 'fake pdf content')
})
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/test.txt',
filePath: '/tmp/test.txt',
mediaType: 'text/plain',
filename: 'test.txt',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(generatePdfFromTextSpy).toHaveBeenCalled()
generatePdfFromTextSpy.mockRestore()
})
it('should generate PDF proxy for markdown files in generatePdfProxyActivity', async () => {
const asset = await prisma.asset.create({
data: { name: 'README.md', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
const generatePdfFromTextSpy = vi
.spyOn(transcodeService, 'generatePdfFromText')
.mockImplementation(async (_inPath, outPath) => {
const fs = await import('fs')
fs.writeFileSync(outPath, 'fake pdf content from md')
})
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/README.md',
filePath: '/tmp/README.md',
mediaType: 'text/markdown',
filename: 'README.md',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(generatePdfFromTextSpy).toHaveBeenCalledWith(
'/tmp/README.md',
expect.stringContaining('proxy.pdf'),
)
generatePdfFromTextSpy.mockRestore()
})
it('should convert markdown document via Gotenberg Chromium in generatePdfProxyActivity when available', async () => {
const asset = await prisma.asset.create({
data: { name: 'README.md', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const convertMdSpy = vi
.spyOn(gotenbergService, 'convertMarkdownToPdf')
.mockResolvedValue(Buffer.from('fake pdf from gotenberg markdown'))
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/README.md',
filePath: '/tmp/README.md',
mediaType: 'text/markdown',
filename: 'README.md',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(convertMdSpy).toHaveBeenCalledWith('/tmp/README.md', 'README.md')
})
it('should convert office document via Gotenberg in generatePdfProxyActivity when available', async () => {
const asset = await prisma.asset.create({
data: { name: 'document.docx', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const convertSpy = vi
.spyOn(gotenbergService, 'convertDocumentToPdf')
.mockResolvedValue(Buffer.from('fake pdf from gotenberg office'))
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/document.docx',
filePath: '/tmp/document.docx',
mediaType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
filename: 'document.docx',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(convertSpy).toHaveBeenCalledWith('/tmp/document.docx', 'document.docx')
})
it('should convert html document via Gotenberg Chromium in generatePdfProxyActivity when available', async () => {
const asset = await prisma.asset.create({
data: { name: 'index.html', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const convertHtmlSpy = vi
.spyOn(gotenbergService, 'convertHtmlToPdf')
.mockResolvedValue(Buffer.from('fake pdf from gotenberg html'))
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/index.html',
filePath: '/tmp/index.html',
mediaType: 'text/html',
filename: 'index.html',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(convertHtmlSpy).toHaveBeenCalledWith('/tmp/index.html', 'index.html')
})
it('should throw ApplicationFailure when Office document conversion is attempted but Gotenberg is unavailable', async () => {
const asset = await prisma.asset.create({
data: { name: 'sheet.xlsx', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
await expect(
generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/sheet.xlsx',
filePath: '/tmp/sheet.xlsx',
mediaType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
filename: 'sheet.xlsx',
}),
).rejects.toThrow('Gotenberg service is required for Office document conversion')
})
it('should throw ApplicationFailure when HTML document conversion is attempted but Gotenberg is unavailable', async () => {
const asset = await prisma.asset.create({
data: { name: 'index.html', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
await expect(
generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/index.html',
filePath: '/tmp/index.html',
mediaType: 'text/html',
filename: 'index.html',
}),
).rejects.toThrow('Gotenberg service is required for HTML document conversion')
})
it('should fallback to transcodeService.generatePdfFromCsv for CSV when Gotenberg is unavailable', async () => {
const asset = await prisma.asset.create({
data: { name: 'data.csv', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
const generatePdfFromCsvSpy = vi
.spyOn(transcodeService, 'generatePdfFromCsv')
.mockImplementation(async (_inPath, outPath) => {
const fs = await import('fs')
fs.writeFileSync(outPath, 'fake pdf from csv fallback')
})
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/data.csv',
filePath: '/tmp/data.csv',
mediaType: 'text/csv',
filename: 'data.csv',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(generatePdfFromCsvSpy).toHaveBeenCalledWith(
'/tmp/data.csv',
expect.stringContaining('proxy.pdf'),
)
generatePdfFromCsvSpy.mockRestore()
})
it('should convert TXT document via Gotenberg when available', async () => {
const asset = await prisma.asset.create({
data: { name: 'notes.txt', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const convertSpy = vi
.spyOn(gotenbergService, 'convertDocumentToPdf')
.mockResolvedValue(Buffer.from('fake pdf from txt gotenberg'))
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/notes.txt',
filePath: '/tmp/notes.txt',
mediaType: 'text/plain',
filename: 'notes.txt',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(convertSpy).toHaveBeenCalledWith('/tmp/notes.txt', 'notes.txt')
})
it('should fallback to transcodeService.generatePdfFromText for TXT when Gotenberg is unavailable', async () => {
const asset = await prisma.asset.create({
data: { name: 'notes.txt', type: 'file', status: 'uploaded' },
})
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
const generatePdfFromTextSpy = vi
.spyOn(transcodeService, 'generatePdfFromText')
.mockImplementation(async (_inPath, outPath) => {
const fs = await import('fs')
fs.writeFileSync(outPath, 'fake pdf from txt fallback')
})
const res = await generatePdfProxyActivity({
assetId: asset.id,
assetKey: 'files/asset1/notes.txt',
filePath: '/tmp/notes.txt',
mediaType: 'text/plain',
filename: 'notes.txt',
})
expect(res.pdfProxyKey).toBe(`files/${asset.id}/proxy.pdf`)
expect(generatePdfFromTextSpy).toHaveBeenCalledWith(
'/tmp/notes.txt',
expect.stringContaining('proxy.pdf'),
)
generatePdfFromTextSpy.mockRestore()
})
it('should set file_type to file for unknown types', async () => {
const asset = await prisma.asset.create({
data: { name: 'u.xyz', type: 'file', status: 'uploaded' },
})
await getMediaInfoActivity({
assetId: asset.id,
filePath: '/tmp/u.xyz',
mediaType: 'application/octet-stream',
})
expect(metadataService.updateAssetMetadata).toHaveBeenCalledWith(
asset.id,
expect.arrayContaining([{ key: 'file_type', value: 'file' }]),
true,
)
2026-05-19 16:05:09 +08:00
})
it('should update asset media field', async () => {
const asset = await prisma.asset.create({
data: {
name: 'v.mp4',
storageKey: { create: { key: 'v.mp4' } },
2026-05-19 16:05:09 +08:00
status: 'uploaded',
type: 'file',
},
})
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mediaInfo: any = { duration: 123 }
await updateAssetMediaActivity({ assetId: asset.id, mediaInfo })
const updated = await prisma.asset.findUnique({ where: { id: asset.id } })
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((updated?.media as any).duration).toBe(123)
expect(s3Service.putObject).toHaveBeenCalled()
})
it('should call transcodeService.transcodeVideo', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not found'))
await transcodeVideoActivity({
assetKey: 'v.mp4',
filePath: '/tmp/v.mp4',
videoSpec: { resolution: '720p', width: 1280, height: 720 },
duration: 10,
originalFps: 30,
hardwareAcceleration: 'auto',
sourceVideoBitrate: 600_000,
2026-05-19 16:05:09 +08:00
})
expect(transcodeService.transcodeVideo).toHaveBeenCalledWith(
expect.objectContaining({
inputFile: '/tmp/v.mp4',
hardwareAcceleration: 'auto',
sourceVideoBitrate: 600_000,
}),
)
2026-05-19 16:05:09 +08:00
})
it('should call transcodeService.takeScreenshots', async () => {
vi.mocked(transcodeService.takeScreenshots).mockResolvedValue([
{ key: 'screenshots/shot1.webp', timestamp: 1.0 },
])
const result = await takeScreenshotsActivity({
assetKey: 'v.mp4',
assetId: 'asset-1',
start: 0,
end: 10,
count: 1,
commentTimestamp: 1.0,
annotations: [],
})
expect(transcodeService.takeScreenshots).toHaveBeenCalledWith({
assetKey: 'v.mp4',
assetId: 'asset-1',
start: 0,
end: 10,
count: 1,
commentTimestamp: 1.0,
annotations: [],
})
expect(result).toEqual([{ key: 'screenshots/shot1.webp', timestamp: 1.0 }])
})
it('should call transcodeService.overlayAnnotations', async () => {
vi.mocked(transcodeService.overlayAnnotations).mockResolvedValue('annotations/ann.webp')
const result = await overlayAnnotationsActivity({
assetKey: 'i.png',
assetId: 'asset-2',
annotations: [],
})
expect(transcodeService.overlayAnnotations).toHaveBeenCalledWith({
assetKey: 'i.png',
assetId: 'asset-2',
annotations: [],
})
expect(result).toBe('annotations/ann.webp')
})
it('should call transcodeService.renderPdfPages', async () => {
vi.mocked(transcodeService.renderPdfPages).mockResolvedValue([
{ key: 'pdf_pages/doc-page-1.webp', page: 1 },
])
const result = await renderPdfPagesActivity({
assetKey: 'doc.pdf',
assetId: 'asset-pdf',
start: 1,
end: 1,
commentTimestamp: 1,
annotations: [],
})
expect(transcodeService.renderPdfPages).toHaveBeenCalledWith({
assetKey: 'doc.pdf',
assetId: 'asset-pdf',
start: 1,
end: 1,
commentTimestamp: 1,
annotations: [],
})
expect(result).toEqual([{ key: 'pdf_pages/doc-page-1.webp', page: 1 }])
})
describe('Non-retryable Error Handling', () => {
it('should throw non-retryable ApplicationFailure when downloadMediaToTmpActivity fails with ENOENT', async () => {
vi.mocked(s3Service.downloadToFile).mockRejectedValue({
code: 'ENOENT',
message: 'ENOENT: no such file or directory',
})
await expect(downloadMediaToTmpActivity({ assetKey: 'missing.mp4' })).rejects.toThrowError(
/Failed to download media to tmp/,
)
})
it('should throw non-retryable ApplicationFailure when getMediaInfoActivity fails with ENOENT', async () => {
const asset = await prisma.asset.create({
data: { name: 'missing.mp4', type: 'file', status: 'uploaded' },
})
vi.mocked(transcodeService.getVideoInfo).mockRejectedValue({
code: 'ENOENT',
message: 'ENOENT: no such file or directory',
})
await expect(
getMediaInfoActivity({
assetId: asset.id,
filePath: '/tmp/missing.mp4',
mediaType: 'video/mp4',
}),
).rejects.toThrowError(/Failed to get media info/)
})
it('should throw non-retryable ApplicationFailure when transcodeVideoActivity fails with ffmpeg error', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not found'))
vi.mocked(transcodeService.transcodeVideo).mockRejectedValue(new Error('FFmpeg failed'))
await expect(
transcodeVideoActivity({
assetKey: 'v.mp4',
filePath: '/tmp/v.mp4',
videoSpec: { resolution: '720p', width: 1280, height: 720 },
duration: 10,
originalFps: 30,
}),
).rejects.toThrowError(/Video transcoding failed/)
})
it('should throw non-retryable ApplicationFailure when transcodeImageActivity fails with sharp error', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not found'))
vi.mocked(transcodeService.transcodeImage).mockRejectedValue(new Error('sharp failed'))
await expect(
transcodeImageActivity({
assetKey: 'i.png',
filePath: '/tmp/i.png',
imageSpec: { width: 800, height: 600, quality: 90, format: 'webp' },
}),
).rejects.toThrowError(/Image transcoding failed/)
})
it('should throw non-retryable ApplicationFailure when transcodeImageActivity fails with ImageMagick error', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not found'))
vi.mocked(transcodeService.transcodeImage).mockRejectedValue(
new Error('imagemagick convert failed'),
)
await expect(
transcodeImageActivity({
assetKey: 'i.psd',
filePath: '/tmp/i.psd',
imageSpec: { width: 800, height: 600, quality: 90, format: 'webp' },
}),
).rejects.toThrowError(/Image transcoding failed/)
})
it('should throw non-retryable ApplicationFailure when generateSpriteActivity fails with error', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not found'))
vi.mocked(transcodeService.generateSprite).mockRejectedValue(new Error('FFmpeg failed'))
await expect(
generateSpriteActivity({
assetKey: 'v.mp4',
filePath: '/tmp/v.mp4',
mediaInfo: { duration: 10 } as unknown as PrismaJson.MediaInfo,
spriteSpec: { key: 'sprite.webp', frames: 100, tileX: 10, tileY: 10 },
posterSpec: { key: 'poster.webp' },
}),
).rejects.toThrowError(/Sprite\/Poster generation failed/)
})
it('should throw non-retryable ApplicationFailure when takeScreenshotsActivity fails with error', async () => {
vi.mocked(transcodeService.takeScreenshots).mockRejectedValue(new Error('FFmpeg failed'))
await expect(
takeScreenshotsActivity({
assetKey: 'v.mp4',
assetId: 'asset-1',
start: 0,
end: 10,
count: 1,
commentTimestamp: 1.0,
annotations: [],
}),
).rejects.toThrowError(/Screenshot extraction failed/)
})
it('should throw non-retryable ApplicationFailure when overlayAnnotationsActivity fails with error', async () => {
vi.mocked(transcodeService.overlayAnnotations).mockRejectedValue(new Error('sharp failed'))
await expect(
overlayAnnotationsActivity({
assetKey: 'i.png',
assetId: 'asset-2',
annotations: [],
}),
).rejects.toThrowError(/Overlay annotations failed/)
})
})
describe('Video Chunk Activities', () => {
it('should transcode video chunk using ffmpeg and upload to S3', async () => {
// Mock child_process.execFile to simulate ffmpeg succeeding
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(child_process.execFile as any).mockImplementation(
(
file: string,
args: string[],
cb: (err: Error | null, result: { stdout: string; stderr: string }) => void,
) => {
cb(null, { stdout: '', stderr: '' })
},
)
const res = await transcodeVideoChunkActivity({
assetId: 'asset-abc',
filePath: '/tmp/full-video.mp4',
startTime: 10,
endTime: 25,
})
// Verify ffmpeg command args
expect(child_process.execFile).toHaveBeenCalledWith(
'ffmpeg',
expect.arrayContaining([
'-y',
'-i',
'/tmp/full-video.mp4',
'-ss',
'10',
'-t',
'15',
'-vf',
'fps=1',
'-c:v',
'libx264',
'-preset',
'ultrafast',
'-crf',
'28',
'-an',
]),
expect.any(Function),
)
// Verify S3 upload
expect(s3Service.putObject).toHaveBeenCalledWith(
'shumai',
expect.stringMatching(/^files\/asset-abc\/tmp-embedding-chunks\/chunk-10-25-.*\.mp4$/),
expect.any(Buffer),
expect.any(Number),
'video/mp4',
)
expect(res.chunkKey).toMatch(/^files\/asset-abc\/tmp-embedding-chunks\/chunk-10-25-.*\.mp4$/)
})
it('should delete S3 object successfully', async () => {
await deleteS3ObjectActivity({ key: 'files/test-key.mp4' })
expect(s3Service.deleteObject).toHaveBeenCalledWith('shumai', 'files/test-key.mp4')
})
it('should transcode audio file and upload proxy to S3', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not found'))
vi.mocked(transcodeService.transcodeAudio).mockResolvedValue()
const res = await transcodeAudioActivity({
assetKey: 'files/proj-123/a.wav',
filePath: '/tmp/a.wav',
})
expect(transcodeService.transcodeAudio).toHaveBeenCalledWith({
inputFile: '/tmp/a.wav',
outputFile: expect.stringContaining('a-audio-proxy.mp4'),
bitrate: '128k',
})
expect(s3Service.putObject).toHaveBeenCalledWith(
'shumai',
'files/proj-123/a-audio-proxy.mp4',
expect.any(ReadableStream),
expect.any(Number),
'video/mp4',
)
expect(res).toEqual({
width: 0,
height: 0,
key: 'files/proj-123/a-audio-proxy.mp4',
})
})
it('should return existing audio transcode if already exists in S3', async () => {
vi.mocked(s3Service.headObject).mockResolvedValue(
{} as Awaited<ReturnType<typeof s3Service.headObject>>,
)
const res = await transcodeAudioActivity({
assetKey: 'files/proj-123/a.wav',
filePath: '/tmp/a.wav',
})
expect(transcodeService.transcodeAudio).not.toHaveBeenCalled()
expect(res).toEqual({
width: 0,
height: 0,
key: 'files/proj-123/a-audio-proxy.mp4',
})
})
it('should create ai_metadata_autofill task when autofill agent exists and asset is image', async () => {
const user = await prisma.user.create({
data: { name: 'Test User Autofill', email: 'test-autofill-agent@test.com' },
})
const team = await prisma.team.create({
data: { name: 'Test Team Autofill' },
})
await prisma.teamMember.create({
data: { teamId: team.id, userId: user.id, role: 'owner' },
})
const project = await prisma.project.create({
data: { name: 'Test Project Autofill', teamId: team.id },
})
const autofillAgent = await prisma.agent.create({
data: {
id: user.id,
type: 'autofill',
enabled: true,
teamId: team.id,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
config: { provider: 'test', model: 'test' } as any,
},
})
const asset = await prisma.asset.create({
data: {
name: 'photo.png',
mediaType: 'image/png',
type: 'file',
status: 'processed',
projectId: project.id,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
media: { proxyType: 'image' } as any,
},
})
await createAutofillTaskIfEnabledActivity({
assetId: asset.id,
teamId: team.id,
projectId: project.id,
})
const task = await prisma.workflowTask.findFirst({
where: { assetId: asset.id, type: 'ai_metadata_autofill' },
})
expect(task).toBeDefined()
expect(task?.status).toBe('pending')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((task?.payload as any)?.agent?.agentId).toBe(autofillAgent.id)
})
})
2026-05-19 16:05:09 +08:00
})