mirror of
https://github.com/advplyr/audiobookshelf.git
synced 2026-02-28 21:19:42 +00:00
466 lines
18 KiB
JavaScript
466 lines
18 KiB
JavaScript
const { expect } = require('chai')
|
|
const sinon = require('sinon')
|
|
const fileUtils = require('../../../server/utils/fileUtils')
|
|
const fs = require('../../../server/libs/fsExtra')
|
|
const EventEmitter = require('events')
|
|
|
|
const { generateFFMetadata, addCoverAndMetadataToFile, extractCoverArt } = require('../../../server/utils/ffmpegHelpers')
|
|
|
|
global.isWin = process.platform === 'win32'
|
|
|
|
describe('generateFFMetadata', () => {
|
|
function createTestSetup() {
|
|
const metadata = {
|
|
title: 'My Audiobook',
|
|
artist: 'John Doe',
|
|
album: 'Best Audiobooks'
|
|
}
|
|
|
|
const chapters = [
|
|
{ start: 0, end: 1000, title: 'Chapter 1' },
|
|
{ start: 1000, end: 2000, title: 'Chapter 2' }
|
|
]
|
|
|
|
return { metadata, chapters }
|
|
}
|
|
|
|
let metadata = null
|
|
let chapters = null
|
|
beforeEach(() => {
|
|
const input = createTestSetup()
|
|
metadata = input.metadata
|
|
chapters = input.chapters
|
|
})
|
|
|
|
it('should generate ffmetadata content with chapters', () => {
|
|
const result = generateFFMetadata(metadata, chapters)
|
|
|
|
expect(result).to.equal(';FFMETADATA1\ntitle=My Audiobook\nartist=John Doe\nalbum=Best Audiobooks\n\n[CHAPTER]\nTIMEBASE=1/1000\nSTART=0\nEND=1000000\ntitle=Chapter 1\n\n[CHAPTER]\nTIMEBASE=1/1000\nSTART=1000000\nEND=2000000\ntitle=Chapter 2\n')
|
|
})
|
|
|
|
it('should generate ffmetadata content without chapters', () => {
|
|
chapters = null
|
|
|
|
const result = generateFFMetadata(metadata, chapters)
|
|
|
|
expect(result).to.equal(';FFMETADATA1\ntitle=My Audiobook\nartist=John Doe\nalbum=Best Audiobooks\n')
|
|
})
|
|
|
|
it('should handle chapters with no title', () => {
|
|
chapters = [
|
|
{ start: 0, end: 1000 },
|
|
{ start: 1000, end: 2000 }
|
|
]
|
|
|
|
const result = generateFFMetadata(metadata, chapters)
|
|
|
|
expect(result).to.equal(';FFMETADATA1\ntitle=My Audiobook\nartist=John Doe\nalbum=Best Audiobooks\n\n[CHAPTER]\nTIMEBASE=1/1000\nSTART=0\nEND=1000000\n\n[CHAPTER]\nTIMEBASE=1/1000\nSTART=1000000\nEND=2000000\n')
|
|
})
|
|
|
|
it('should handle metadata escaping special characters (=, ;, #, and a newline)', () => {
|
|
metadata.title = 'My Audiobook; with = special # characters\n'
|
|
chapters[0].title = 'Chapter #1'
|
|
|
|
const result = generateFFMetadata(metadata, chapters)
|
|
|
|
expect(result).to.equal(';FFMETADATA1\ntitle=My Audiobook\\; with \\= special \\# characters\\\n\nartist=John Doe\nalbum=Best Audiobooks\n\n[CHAPTER]\nTIMEBASE=1/1000\nSTART=0\nEND=1000000\ntitle=Chapter \\#1\n\n[CHAPTER]\nTIMEBASE=1/1000\nSTART=1000000\nEND=2000000\ntitle=Chapter 2\n')
|
|
})
|
|
})
|
|
|
|
describe('addCoverAndMetadataToFile', () => {
|
|
function createTestSetup() {
|
|
const audioFilePath = '/path/to/audio/file.mp3'
|
|
const coverFilePath = '/path/to/cover/image.jpg'
|
|
const metadataFilePath = '/path/to/metadata/file.txt'
|
|
const track = 1
|
|
const mimeType = 'audio/mpeg'
|
|
|
|
const ffmpegStub = new EventEmitter()
|
|
ffmpegStub.input = sinon.stub().returnsThis()
|
|
ffmpegStub.outputOptions = sinon.stub().returnsThis()
|
|
ffmpegStub.output = sinon.stub().returnsThis()
|
|
ffmpegStub.input = sinon.stub().returnsThis()
|
|
ffmpegStub.run = sinon.stub().callsFake(() => {
|
|
ffmpegStub.emit('end')
|
|
})
|
|
const copyStub = sinon.stub().resolves()
|
|
const fsRemoveStub = sinon.stub(fs, 'remove').resolves()
|
|
|
|
return { audioFilePath, coverFilePath, metadataFilePath, track, mimeType, ffmpegStub, copyStub, fsRemoveStub }
|
|
}
|
|
|
|
let audioFilePath = null
|
|
let coverFilePath = null
|
|
let metadataFilePath = null
|
|
let track = null
|
|
let mimeType = null
|
|
let ffmpegStub = null
|
|
let copyStub = null
|
|
let fsRemoveStub = null
|
|
beforeEach(() => {
|
|
const input = createTestSetup()
|
|
audioFilePath = input.audioFilePath
|
|
coverFilePath = input.coverFilePath
|
|
metadataFilePath = input.metadataFilePath
|
|
track = input.track
|
|
mimeType = input.mimeType
|
|
ffmpegStub = input.ffmpegStub
|
|
copyStub = input.copyStub
|
|
fsRemoveStub = input.fsRemoveStub
|
|
})
|
|
|
|
it('should add cover image and metadata to audio file', async () => {
|
|
// Act
|
|
await addCoverAndMetadataToFile(audioFilePath, coverFilePath, metadataFilePath, track, mimeType, null, ffmpegStub, copyStub)
|
|
|
|
// Assert
|
|
expect(ffmpegStub.input.calledThrice).to.be.true
|
|
expect(ffmpegStub.input.getCall(0).args[0]).to.equal(audioFilePath)
|
|
expect(ffmpegStub.input.getCall(1).args[0]).to.equal(metadataFilePath)
|
|
expect(ffmpegStub.input.getCall(2).args[0]).to.equal(coverFilePath)
|
|
|
|
expect(ffmpegStub.outputOptions.callCount).to.equal(4)
|
|
expect(ffmpegStub.outputOptions.getCall(0).args[0]).to.deep.equal(['-map 0:a', '-map_metadata 1', '-map_metadata 0', '-map_chapters 1', '-c copy'])
|
|
expect(ffmpegStub.outputOptions.getCall(1).args[0]).to.deep.equal(['-metadata track=1'])
|
|
expect(ffmpegStub.outputOptions.getCall(2).args[0]).to.deep.equal(['-id3v2_version 3'])
|
|
expect(ffmpegStub.outputOptions.getCall(3).args[0]).to.deep.equal(['-map 2:v', '-disposition:v:0 attached_pic', '-metadata:s:v', 'title=Cover', '-metadata:s:v', 'comment=Cover'])
|
|
|
|
expect(ffmpegStub.output.calledOnce).to.be.true
|
|
expect(ffmpegStub.output.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
|
|
expect(ffmpegStub.run.calledOnce).to.be.true
|
|
|
|
expect(copyStub.calledOnce).to.be.true
|
|
expect(copyStub.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
expect(copyStub.firstCall.args[1]).to.equal('/path/to/audio/file.mp3')
|
|
expect(fsRemoveStub.calledOnce).to.be.true
|
|
expect(fsRemoveStub.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
|
|
// Restore the stub
|
|
sinon.restore()
|
|
})
|
|
|
|
it('should handle missing cover image', async () => {
|
|
// Arrange
|
|
coverFilePath = null
|
|
|
|
// Act
|
|
await addCoverAndMetadataToFile(audioFilePath, coverFilePath, metadataFilePath, track, mimeType, null, ffmpegStub, copyStub)
|
|
|
|
// Assert
|
|
expect(ffmpegStub.input.calledTwice).to.be.true
|
|
expect(ffmpegStub.input.getCall(0).args[0]).to.equal(audioFilePath)
|
|
expect(ffmpegStub.input.getCall(1).args[0]).to.equal(metadataFilePath)
|
|
|
|
expect(ffmpegStub.outputOptions.callCount).to.equal(4)
|
|
expect(ffmpegStub.outputOptions.getCall(0).args[0]).to.deep.equal(['-map 0:a', '-map_metadata 1', '-map_metadata 0', '-map_chapters 1', '-c copy'])
|
|
expect(ffmpegStub.outputOptions.getCall(1).args[0]).to.deep.equal(['-metadata track=1'])
|
|
expect(ffmpegStub.outputOptions.getCall(2).args[0]).to.deep.equal(['-id3v2_version 3'])
|
|
expect(ffmpegStub.outputOptions.getCall(3).args[0]).to.deep.equal(['-map 0:v?'])
|
|
|
|
expect(ffmpegStub.output.calledOnce).to.be.true
|
|
expect(ffmpegStub.output.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
|
|
expect(ffmpegStub.run.calledOnce).to.be.true
|
|
|
|
expect(copyStub.callCount).to.equal(1)
|
|
expect(copyStub.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
expect(copyStub.firstCall.args[1]).to.equal('/path/to/audio/file.mp3')
|
|
expect(fsRemoveStub.calledOnce).to.be.true
|
|
expect(fsRemoveStub.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
|
|
// Restore the stub
|
|
sinon.restore()
|
|
})
|
|
|
|
it('should handle error during ffmpeg execution', async () => {
|
|
// Arrange
|
|
ffmpegStub.run = sinon.stub().callsFake(() => {
|
|
ffmpegStub.emit('error', new Error('FFmpeg error'))
|
|
})
|
|
|
|
// Act
|
|
try {
|
|
await addCoverAndMetadataToFile(audioFilePath, coverFilePath, metadataFilePath, track, mimeType, null, ffmpegStub, copyStub)
|
|
expect.fail('Expected an error to be thrown')
|
|
} catch (error) {
|
|
// Assert
|
|
expect(error.message).to.equal('FFmpeg error')
|
|
}
|
|
|
|
// Assert
|
|
expect(ffmpegStub.input.calledThrice).to.be.true
|
|
expect(ffmpegStub.input.getCall(0).args[0]).to.equal(audioFilePath)
|
|
expect(ffmpegStub.input.getCall(1).args[0]).to.equal(metadataFilePath)
|
|
expect(ffmpegStub.input.getCall(2).args[0]).to.equal(coverFilePath)
|
|
|
|
expect(ffmpegStub.outputOptions.callCount).to.equal(4)
|
|
expect(ffmpegStub.outputOptions.getCall(0).args[0]).to.deep.equal(['-map 0:a', '-map_metadata 1', '-map_metadata 0', '-map_chapters 1', '-c copy'])
|
|
expect(ffmpegStub.outputOptions.getCall(1).args[0]).to.deep.equal(['-metadata track=1'])
|
|
expect(ffmpegStub.outputOptions.getCall(2).args[0]).to.deep.equal(['-id3v2_version 3'])
|
|
expect(ffmpegStub.outputOptions.getCall(3).args[0]).to.deep.equal(['-map 2:v', '-disposition:v:0 attached_pic', '-metadata:s:v', 'title=Cover', '-metadata:s:v', 'comment=Cover'])
|
|
|
|
expect(ffmpegStub.output.calledOnce).to.be.true
|
|
expect(ffmpegStub.output.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.mp3')
|
|
|
|
expect(ffmpegStub.run.calledOnce).to.be.true
|
|
|
|
expect(copyStub.called).to.be.false
|
|
expect(fsRemoveStub.called).to.be.false
|
|
|
|
// Restore the stub
|
|
sinon.restore()
|
|
})
|
|
|
|
it('should handle m4b embedding', async () => {
|
|
// Arrange
|
|
mimeType = 'audio/mp4'
|
|
audioFilePath = '/path/to/audio/file.m4b'
|
|
|
|
// Act
|
|
await addCoverAndMetadataToFile(audioFilePath, coverFilePath, metadataFilePath, track, mimeType, null, ffmpegStub, copyStub)
|
|
|
|
// Assert
|
|
expect(ffmpegStub.input.calledThrice).to.be.true
|
|
expect(ffmpegStub.input.getCall(0).args[0]).to.equal(audioFilePath)
|
|
expect(ffmpegStub.input.getCall(1).args[0]).to.equal(metadataFilePath)
|
|
expect(ffmpegStub.input.getCall(2).args[0]).to.equal(coverFilePath)
|
|
|
|
expect(ffmpegStub.outputOptions.callCount).to.equal(4)
|
|
expect(ffmpegStub.outputOptions.getCall(0).args[0]).to.deep.equal(['-map 0:a', '-map_metadata 1', '-map_metadata 0', '-map_chapters 1', '-c copy'])
|
|
expect(ffmpegStub.outputOptions.getCall(1).args[0]).to.deep.equal(['-metadata track=1'])
|
|
expect(ffmpegStub.outputOptions.getCall(2).args[0]).to.deep.equal(['-f mp4'])
|
|
expect(ffmpegStub.outputOptions.getCall(3).args[0]).to.deep.equal(['-map 2:v', '-disposition:v:0 attached_pic', '-metadata:s:v', 'title=Cover', '-metadata:s:v', 'comment=Cover'])
|
|
|
|
expect(ffmpegStub.output.calledOnce).to.be.true
|
|
expect(ffmpegStub.output.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.m4b')
|
|
|
|
expect(ffmpegStub.run.calledOnce).to.be.true
|
|
|
|
expect(copyStub.calledOnce).to.be.true
|
|
expect(copyStub.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.m4b')
|
|
expect(copyStub.firstCall.args[1]).to.equal('/path/to/audio/file.m4b')
|
|
expect(fsRemoveStub.calledOnce).to.be.true
|
|
expect(fsRemoveStub.firstCall.args[0]).to.equal('/path/to/audio/file.tmp.m4b')
|
|
|
|
// Restore the stub
|
|
sinon.restore()
|
|
})
|
|
})
|
|
|
|
describe('extractCoverArt', () => {
|
|
function createTestSetup() {
|
|
const filepath = '/path/to/audio/file.m4b'
|
|
const outputpath = '/path/to/output/cover.jpg'
|
|
|
|
const ffmpegCommandStub = new EventEmitter()
|
|
ffmpegCommandStub.addOption = sinon.stub().returnsThis()
|
|
ffmpegCommandStub.output = sinon.stub().returnsThis()
|
|
ffmpegCommandStub.run = sinon.stub().callsFake(() => {
|
|
ffmpegCommandStub.emit('end')
|
|
})
|
|
|
|
const ffmpegModuleStub = sinon.stub().returns(ffmpegCommandStub)
|
|
ffmpegModuleStub.ffprobe = sinon.stub()
|
|
|
|
const ensureDirStub = sinon.stub(fs, 'ensureDir').resolves()
|
|
|
|
return { filepath, outputpath, ffmpegCommandStub, ffmpegModuleStub, ensureDirStub }
|
|
}
|
|
|
|
let filepath = null
|
|
let outputpath = null
|
|
let ffmpegCommandStub = null
|
|
let ffmpegModuleStub = null
|
|
let ensureDirStub = null
|
|
|
|
beforeEach(() => {
|
|
const input = createTestSetup()
|
|
filepath = input.filepath
|
|
outputpath = input.outputpath
|
|
ffmpegCommandStub = input.ffmpegCommandStub
|
|
ffmpegModuleStub = input.ffmpegModuleStub
|
|
ensureDirStub = input.ensureDirStub
|
|
})
|
|
|
|
afterEach(() => {
|
|
sinon.restore()
|
|
})
|
|
|
|
it('should extract cover art from a file with a single video stream', async () => {
|
|
// Arrange
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'audio', index: 0 },
|
|
{ codec_type: 'video', index: 1, width: 400, height: 400 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegModuleStub.ffprobe.calledOnce).to.be.true
|
|
expect(ffmpegModuleStub.ffprobe.firstCall.args[0]).to.equal(filepath)
|
|
expect(ffmpegCommandStub.addOption.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.addOption.firstCall.args[0]).to.deep.equal(['-map 0:1', '-frames:v 1'])
|
|
expect(ffmpegCommandStub.output.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.output.firstCall.args[0]).to.equal(outputpath)
|
|
expect(ffmpegCommandStub.run.calledOnce).to.be.true
|
|
expect(result).to.equal(outputpath)
|
|
})
|
|
|
|
it('should select the largest video stream when multiple exist and ignore 1x1 placeholder', async () => {
|
|
// Arrange - simulate the Christmas Carol case with 1x1 and 400x400 streams
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'audio', index: 0 },
|
|
{ codec_type: 'video', index: 1, width: 1, height: 1 },
|
|
{ codec_type: 'audio', index: 2 },
|
|
{ codec_type: 'video', index: 3, width: 400, height: 400 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegModuleStub.ffprobe.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.addOption.calledOnce).to.be.true
|
|
// Should select index 3 (400x400) and ignore index 1 (1x1)
|
|
expect(ffmpegCommandStub.addOption.firstCall.args[0]).to.deep.equal(['-map 0:3', '-frames:v 1'])
|
|
expect(result).to.equal(outputpath)
|
|
})
|
|
|
|
it('should select the largest video stream among multiple sizes', async () => {
|
|
// Arrange - test with various resolutions
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'video', index: 0, width: 100, height: 100 }, // 10,000 pixels
|
|
{ codec_type: 'video', index: 1, width: 200, height: 150 }, // 30,000 pixels
|
|
{ codec_type: 'video', index: 2, width: 300, height: 200 }, // 60,000 pixels (largest)
|
|
{ codec_type: 'video', index: 3, width: 150, height: 300 } // 45,000 pixels
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegCommandStub.addOption.firstCall.args[0]).to.deep.equal(['-map 0:2', '-frames:v 1'])
|
|
expect(result).to.equal(outputpath)
|
|
})
|
|
|
|
it('should ignore video streams with missing width/height and select valid ones', async () => {
|
|
// Arrange
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'video', index: 0 }, // no dimensions (will be filtered out)
|
|
{ codec_type: 'video', index: 1, width: 400, height: 400 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
// Should ignore index 0 (no dimensions) and select index 1 (400x400)
|
|
expect(ffmpegCommandStub.addOption.firstCall.args[0]).to.deep.equal(['-map 0:1', '-frames:v 1'])
|
|
expect(result).to.equal(outputpath)
|
|
})
|
|
|
|
it('should return false when ffprobe fails', async () => {
|
|
// Arrange
|
|
ffmpegModuleStub.ffprobe.yields(new Error('ffprobe error'), null)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegModuleStub.ffprobe.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.run.called).to.be.false
|
|
expect(result).to.be.false
|
|
})
|
|
|
|
it('should return false when no video streams found', async () => {
|
|
// Arrange
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'audio', index: 0 },
|
|
{ codec_type: 'audio', index: 1 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegModuleStub.ffprobe.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.run.called).to.be.false
|
|
expect(result).to.be.false
|
|
})
|
|
|
|
it('should return false when only tiny placeholder images exist (width or height <= 1)', async () => {
|
|
// Arrange
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'audio', index: 0 },
|
|
{ codec_type: 'video', index: 1, width: 1, height: 1 },
|
|
{ codec_type: 'video', index: 2, width: 0, height: 100 },
|
|
{ codec_type: 'video', index: 3, width: 100, height: 1 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegModuleStub.ffprobe.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.run.called).to.be.false
|
|
expect(result).to.be.false
|
|
})
|
|
|
|
it('should return false when ffmpeg extraction fails', async () => {
|
|
// Arrange
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'video', index: 0, width: 400, height: 400 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
ffmpegCommandStub.run = sinon.stub().callsFake(() => {
|
|
ffmpegCommandStub.emit('error', new Error('FFmpeg extraction error'))
|
|
})
|
|
|
|
// Act
|
|
const result = await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ffmpegModuleStub.ffprobe.calledOnce).to.be.true
|
|
expect(ffmpegCommandStub.run.calledOnce).to.be.true
|
|
expect(result).to.be.false
|
|
})
|
|
|
|
it('should ensure output directory exists', async () => {
|
|
// Arrange
|
|
const metadata = {
|
|
streams: [
|
|
{ codec_type: 'video', index: 0, width: 400, height: 400 }
|
|
]
|
|
}
|
|
ffmpegModuleStub.ffprobe.yields(null, metadata)
|
|
|
|
// Act
|
|
await extractCoverArt(filepath, outputpath, ffmpegModuleStub)
|
|
|
|
// Assert
|
|
expect(ensureDirStub.calledOnce).to.be.true
|
|
expect(ensureDirStub.firstCall.args[0]).to.equal('/path/to/output')
|
|
})
|
|
})
|