336 lines
20 KiB
JavaScript
336 lines
20 KiB
JavaScript
'use strict';
|
|
const path = require('path');
|
|
const os = require('os');
|
|
const fs = require('fs');
|
|
|
|
const ROOT = process.cwd();
|
|
let passed = 0, failed = 0;
|
|
function ok(cond, msg) {
|
|
if (cond) { console.log(` [PASS] ${msg}`); passed++; }
|
|
else { console.error(` [FAIL] ${msg}`); failed++; }
|
|
}
|
|
function eq(a, b, msg) { ok(String(a) === String(b), `${msg} (expected "${b}", got "${a}")`); }
|
|
|
|
function makeStream(o) {
|
|
return Object.assign({
|
|
index: 0, codec_type: 'video', codec_name: 'h264',
|
|
r_frame_rate: '24/1', avg_frame_rate: '24/1',
|
|
width: 1920, height: 1080, channels: 2,
|
|
bit_rate: '0', tags: {}, disposition: {}, profile: '',
|
|
}, o);
|
|
}
|
|
function makeArgs(filePath, streams, inputs, variables) {
|
|
const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tdarr-logic-'));
|
|
return {
|
|
inputFileObj: { _id: filePath, ffProbeData: { streams }, mediaInfo: { track: [] } },
|
|
variables: Object.assign({}, variables || {}),
|
|
inputs: inputs || {},
|
|
workDir,
|
|
ffmpegPath: 'ffmpeg',
|
|
mkvpropeditPath: 'mkvpropedit',
|
|
jobLog: () => {},
|
|
_workDir: workDir,
|
|
};
|
|
}
|
|
function cleanup(a) { try { fs.rmSync(a._workDir, { recursive: true, force: true }); } catch(_){} }
|
|
|
|
const { plugin: analyzerPlugin } = require(path.join(ROOT, 'LocalFlowPlugins/utility/mediaAnalyzerGOP/1.0.0/index'));
|
|
const { plugin: audioPlugin } = require(path.join(ROOT, 'LocalFlowPlugins/audio/audioSelectorClamping/1.0.0/index'));
|
|
|
|
const ANALYZER_INPUTS = {
|
|
moviePathPatterns: '/Radarr', animeSeries: 'Naruto|One Piece',
|
|
filmBitrate: '3000', seriesBitrate: '3000', animeBitrateHd: '2000', animeBitrateSd: '1000',
|
|
};
|
|
const AUDIO_INPUTS = {
|
|
filmMultiChannelBitrate: '640', seriesMultiChannelThreshold: '384', stereoBitrateMax: '128',
|
|
};
|
|
|
|
(async () => {
|
|
// ── mediaAnalyzerGOP ──────────────────────────────────────────────────────
|
|
console.log('\n── mediaAnalyzerGOP ──────────────────────────────────');
|
|
|
|
{ const a = makeArgs('/media/toshiba/Radarr/Film (2023)/Film.mkv',
|
|
[makeStream({ r_frame_rate:'24000/1001', height:1080 })], ANALYZER_INPUTS);
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.gopKeyint, '96', '23.976fps -> keyint=96 (4 seconds)');
|
|
eq(o.variables.gopMinKeyint, '24', '23.976fps -> min-keyint=24 (1 second)');
|
|
eq(o.variables.gopSceneCut, '40', 'scene-cut threshold is 40');
|
|
eq(o.variables.isMovie, 'true', '/Radarr -> isMovie=true');
|
|
eq(o.variables.isAnimation, 'false', 'no anime -> isAnimation=false');
|
|
eq(o.variables.vBitrate, '3000k', 'film bitrate=3000k');
|
|
eq(o.variables.vMaxRate, '6000k', 'maxrate=2x');
|
|
eq(o.variables.vBufSize, '12000k', 'bufsize=4x');
|
|
eq(o.variables.x265Tune, '', 'live-action -> no tune');
|
|
cleanup(a); }
|
|
|
|
{ const a = makeArgs('/media/toshiba/Sonarr/Naruto S01/S01E01.mkv',
|
|
[makeStream({ r_frame_rate:'25/1', height:720 })], ANALYZER_INPUTS);
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.gopKeyint, '100', '25fps -> keyint=100 (4 seconds)');
|
|
eq(o.variables.isMovie, 'false', '/Sonarr -> isMovie=false');
|
|
eq(o.variables.isAnimation, 'true', 'Naruto -> isAnimation=true');
|
|
eq(o.variables.x265Tune, 'animation', 'anime -> tune=animation');
|
|
eq(o.variables.vBitrate, '2000k', 'anime 720p HD -> 2000k');
|
|
cleanup(a); }
|
|
|
|
{ const a = makeArgs('/media/toshiba/Sonarr/Naruto S01/S01E01.mkv',
|
|
[makeStream({ r_frame_rate:'30000/1001', height:480 })], ANALYZER_INPUTS);
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.gopKeyint, '120', '29.97fps -> keyint=120 (4 seconds)');
|
|
eq(o.variables.vBitrate, '1000k', 'anime SD 480p -> 1000k');
|
|
cleanup(a); }
|
|
|
|
// Windows backslash path normalization
|
|
{ const a = makeArgs('C:\\media\\toshiba\\Radarr\\Film (2023)\\Film.mkv',
|
|
[makeStream({ r_frame_rate:'24/1', height:1080 })], ANALYZER_INPUTS);
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.isMovie, 'true', 'Windows backslash path: /Radarr still matched');
|
|
cleanup(a); }
|
|
|
|
// Family Guy (space in anime list, dots in folder & file name)
|
|
{ const a = makeArgs('/media/toshiba/Sonarr/Family.Guy.1999 [tvdbid-75978]/Family.Guy.S00/Family.Guy.S00E64.mkv',
|
|
[makeStream({ r_frame_rate:'24000/1001', height:1080 })],
|
|
Object.assign({}, ANALYZER_INPUTS, { animeSeries: 'Simpson|Griffin|Family Guy|South Park' }));
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.isAnimation, 'true', 'Family Guy (dots vs spaces in name): isAnimation=true');
|
|
eq(o.variables.x265Tune, 'animation', 'Family Guy: x265Tune=animation');
|
|
eq(o.variables.vBitrate, '2000k', 'Family Guy 1080p: anime HD bitrate=2000k');
|
|
cleanup(a); }
|
|
|
|
// Anime detected via variables.originalLibraryFile when workDir copy is input
|
|
{ const a = makeArgs('C:\\workDir\\Family.Guy.S00E64_old.mkv',
|
|
[makeStream({ r_frame_rate:'24000/1001', height:1080 })],
|
|
Object.assign({}, ANALYZER_INPUTS, { animeSeries: 'Family Guy' }),
|
|
{ originalLibraryFile: '/media/toshiba/Sonarr/Family.Guy.1999/Family.Guy.S00/Family.Guy.S00E64.mkv' });
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.isAnimation, 'true', 'Anime detected via originalLibraryFile in variables');
|
|
cleanup(a); }
|
|
|
|
// Accents and apostrophe handling in anime list
|
|
{ const a = makeArgs('/media/toshiba/Sonarr/Pokemon.S01E01.mkv',
|
|
[makeStream({ r_frame_rate:'24/1', height:720 })],
|
|
Object.assign({}, ANALYZER_INPUTS, { animeSeries: 'Pokémon' }));
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.isAnimation, 'true', 'Accented title "Pokémon" matches "Pokemon.S01E01.mkv"');
|
|
cleanup(a); }
|
|
|
|
{ const a = makeArgs('/media/toshiba/Sonarr/Bobs.Burgers.S01E01.mkv',
|
|
[makeStream({ r_frame_rate:'24/1', height:720 })],
|
|
Object.assign({}, ANALYZER_INPUTS, { animeSeries: "Bob's Burgers" }));
|
|
const o = await analyzerPlugin(a);
|
|
eq(o.variables.isAnimation, 'true', 'Apostrophe title "Bob\'s Burgers" matches "Bobs.Burgers"');
|
|
cleanup(a); }
|
|
|
|
// ── audioSelectorClamping ─────────────────────────────────────────────────
|
|
console.log('\n── audioSelectorClamping ────────────────────────────');
|
|
|
|
// EAC3 wins over AC3 by score
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'448000', channels:6, tags:{language:'ita'} }),
|
|
makeStream({ index:2, codec_type:'audio', codec_name:'eac3', bit_rate:'640000', channels:6, tags:{language:'eng'} }),
|
|
];
|
|
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.outputNumber, 1, 'output 1 = tracks found');
|
|
eq(o.variables.audioItaCodecName, 'ac3', 'ITA=ac3');
|
|
eq(o.variables.audioEngCodecName, 'eac3', 'ENG=eac3');
|
|
eq(o.variables.audioItaOpusBitrate, '448', 'ITA=min(640,448)=448');
|
|
eq(o.variables.audioEngOpusBitrate, '640', 'ENG=min(640,640)=640');
|
|
cleanup(a); }
|
|
|
|
// EAC3 640k vs AC3 680k same lang — EAC3 wins by weight
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'eac3', bit_rate:'640000', channels:6, tags:{language:'ita'} }),
|
|
makeStream({ index:2, codec_type:'audio', codec_name:'ac3', bit_rate:'680000', channels:6, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaCodecName, 'eac3', 'EAC3@640k > AC3@680k by codec weight');
|
|
eq(o.variables.audioItaStreamIndex, '1', 'EAC3 at stream index 1');
|
|
cleanup(a); }
|
|
|
|
// Series DTS 768k >= 384 threshold -> 384
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'dts', bit_rate:'768000', channels:6, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '384', 'Series DTS 768k >= 384 -> Opus=384');
|
|
cleanup(a); }
|
|
|
|
// Series AC3 320k < 384 target -> 320 (strict no upcoding)
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'320000', channels:6, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false', isAnimation:'false' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '320', 'Series AC3 320k -> min(384,320)=320 (no upcoding)');
|
|
cleanup(a); }
|
|
|
|
// Series multichannel low bitrate 192k -> 192 (strict no upcoding to 256)
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'aac', bit_rate:'192000', channels:6, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false', isAnimation:'false' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '192', 'Series 192k multichannel -> stays 192k (never upcoded to 256)');
|
|
cleanup(a); }
|
|
|
|
// Series / Animation with 256k threshold -> capped at 256k
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'448000', channels:6, tags:{language:'ita'} }),
|
|
];
|
|
const customInputs = Object.assign({}, AUDIO_INPUTS, { seriesMultiChannelThreshold: '256' });
|
|
const a = makeArgs('/media/Sonarr/Naruto/ep.mkv', streams, customInputs, { isMovie:'false' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '256', 'Animation 448k multichannel with 256k threshold -> capped at 256k');
|
|
cleanup(a); }
|
|
|
|
// Detection via tags.BPS when stream.bit_rate is 0
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'0', channels:6, tags:{language:'ita', BPS:'384000'} }),
|
|
];
|
|
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false', isAnimation:'false' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '384', 'Bitrate detected from tags.BPS -> 384k');
|
|
cleanup(a); }
|
|
|
|
// Series bitrate unknown (0) and no BPS tag -> safe default 384k
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'dts', bit_rate:'0', channels:6, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Sonarr/Show/ep.mkv', streams, AUDIO_INPUTS, { isMovie:'false', isAnimation:'false' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '384', 'Series unknown bitrate (0) -> safe default 384k');
|
|
cleanup(a); }
|
|
|
|
// Stereo: min(128,192)=128
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'aac', bit_rate:'192000', channels:2, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioItaOpusBitrate, '128', 'Stereo 192k -> min(128,192)=128');
|
|
cleanup(a); }
|
|
|
|
// Stereo: no upcoding — min(128,64)=64
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'aac', bit_rate:'64000', channels:2, tags:{language:'eng'} }),
|
|
];
|
|
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.variables.audioEngOpusBitrate, '64', 'Stereo 64k -> no upcoding, stays 64k');
|
|
cleanup(a); }
|
|
|
|
// No ITA/ENG -> output branch 2
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'ac3', bit_rate:'448000', channels:6, tags:{language:'fra'} }),
|
|
];
|
|
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
|
const o = await audioPlugin(a);
|
|
eq(o.outputNumber, 2, 'No ITA/ENG -> output branch 2');
|
|
cleanup(a); }
|
|
|
|
// DTS-HD MA detection via profile field
|
|
{ const streams = [
|
|
makeStream({ index:0, codec_type:'video' }),
|
|
makeStream({ index:1, codec_type:'audio', codec_name:'dts', profile:'DTS-HD MA', bit_rate:'4000000', channels:8, tags:{language:'ita'} }),
|
|
];
|
|
const a = makeArgs('/media/Radarr/Film.mkv', streams, AUDIO_INPUTS, { isMovie:'true' });
|
|
const o = await audioPlugin(a);
|
|
// DTS-HD MA weight=95, score=95*10000+4000=954000 — should be selected
|
|
eq(o.variables.audioItaCodecName, 'dts', 'DTS-HD MA detected (codec_name=dts, profile contains MA)');
|
|
// source 4000kbps, film target 640 -> Opus=min(640,4000)=640
|
|
eq(o.variables.audioItaOpusBitrate, '640', 'DTS-HD MA 4Mbps film -> clamped to 640k');
|
|
cleanup(a); }
|
|
|
|
// ── buildAudioArgs structure check ────────────────────────────────────────
|
|
console.log('\n── transcode2PassX265 buildAudioArgs structure ──────');
|
|
const { plugin: transcodePlugin } = require(path.join(ROOT, 'LocalFlowPlugins/video/transcode2PassX265/1.0.0/index'));
|
|
// Inspect the buildAudioArgs function by reading the file
|
|
const transcodeCode = require('fs').readFileSync(path.join(ROOT, 'LocalFlowPlugins/video/transcode2PassX265/1.0.0/index.js'), 'utf8');
|
|
ok(transcodeCode.includes('`-c:a:${audioTrackOut}`'), 'buildAudioArgs uses indexed -c:a:N (not global -c:a)');
|
|
ok(transcodeCode.includes('`-b:a:${audioTrackOut}`'), 'buildAudioArgs uses indexed -b:a:N (not global -b:a)');
|
|
ok(transcodeCode.includes('[...mapArgs, ...codecArgs]'), 'buildAudioArgs: maps first, then codec settings');
|
|
ok(!transcodeCode.includes("'-c:a', 'libopus'"), 'no unindexed -c:a in buildAudioArgs');
|
|
ok(transcodeCode.includes('bitrateKbps < copyHevcBelowKbps'), 'HEVC copy requires bitrate strictly below the limit');
|
|
ok(transcodeCode.includes("copyHevcBelowKbps || '3000'"), 'HEVC copy limit defaults to 3000 kbps');
|
|
ok(transcodeCode.includes("'-c:v', 'copy'"), 'compatible HEVC video uses stream copy');
|
|
ok(transcodeCode.includes("normalizedKey === 'bps' || normalizedKey === 'bps-eng'"), 'HEVC copy check falls back to Matroska BPS metadata');
|
|
ok(transcodeCode.includes('containerBitrate - otherStreamBitrate'), 'HEVC copy check estimates video bitrate from container and companion streams');
|
|
ok(!transcodeCode.includes("'-map_metadata -1'"), 'pass 1 separates -map_metadata from its value');
|
|
ok(transcodeCode.includes('const statsForX265 = path.basename(statsFile)'), 'x265 stats file is relative to workDir on Windows');
|
|
const { scalePassPercentage } = require(path.join(ROOT, 'LocalFlowPlugins/video/transcode2PassX265/1.0.0/index.js'));
|
|
eq(scalePassPercentage(1, 0), 0, 'pass 1 at 0% maps to 0%');
|
|
eq(scalePassPercentage(1, 50), 25, 'pass 1 at 50% maps to 25%');
|
|
eq(scalePassPercentage(1, 100), 50, 'pass 1 at 100% maps to 50%');
|
|
eq(scalePassPercentage(2, 0), 50, 'pass 2 at 0% maps to 50%');
|
|
eq(scalePassPercentage(2, 50), 75, 'pass 2 at 50% maps to 75%');
|
|
eq(scalePassPercentage(2, 100), 100, 'pass 2 at 100% maps to 100%');
|
|
ok(transcodeCode.includes('scalePassPercentage(1,'), 'pass 1 wraps updateWorker with 50% scale');
|
|
ok(transcodeCode.includes('scalePassPercentage(2,'), 'pass 2 wraps updateWorker with 50% scale');
|
|
ok(transcodeCode.includes("displayFile = (variables.originalLibraryFile || inputFile).replace(/\\\\/g, '/')"), 'transcode2PassX265 normalizes displayFile with forward slashes');
|
|
ok(transcodeCode.includes('file: displayFile'), 'transcode2PassX265 passes displayFile to updateWorker');
|
|
ok(transcodeCode.includes("'-metadata', `title=${baseName}`"), 'transcode2PassX265 restores metadata title tag in output MKV');
|
|
ok(transcodeCode.includes("outFile = path.join(workDir, `${baseName}.${container}`).replace(/\\\\/g, '/')"), 'transcode2PassX265 normalizes outFile with forward slashes');
|
|
|
|
// Verify WebUI worker title logic: `t.file ? (e = t.file).includes("/") ? e.split("/").pop() : "" : ""`
|
|
{
|
|
const sampleWorkerFile = 'C:/media/toshiba/Sonarr/Family.Guy.1999/Family.Guy.S00/Family.Guy.S00E64.mkv';
|
|
const webUiTitle = sampleWorkerFile ? (sampleWorkerFile.includes('/') ? sampleWorkerFile.split('/').pop() : '') : '';
|
|
eq(webUiTitle, 'Family.Guy.S00E64.mkv', 'WebUI title extract works with forward slashes');
|
|
|
|
const sampleWindowsFile = 'C:\\media\\toshiba\\Sonarr\\Family.Guy.1999\\Family.Guy.S00\\Family.Guy.S00E64.mkv';
|
|
const brokenWebUiTitle = sampleWindowsFile ? (sampleWindowsFile.includes('/') ? sampleWindowsFile.split('/').pop() : '') : '';
|
|
eq(brokenWebUiTitle, '', 'Confirms WebUI bug: Windows backslashes produce empty title');
|
|
}
|
|
|
|
// ── copyToWorkDir & replaceOriginalFile v1.0.0 checks ─────────────────────
|
|
const copyPluginCode = require('fs').readFileSync(path.join(ROOT, 'LocalFlowPlugins/utility/copyToWorkDir/1.0.0/index.js'), 'utf8');
|
|
ok(copyPluginCode.includes('copyWithProgress'), 'copyToWorkDir v1 uses copyWithProgress');
|
|
ok(copyPluginCode.includes('updateWorker'), 'copyToWorkDir v1 forwards updateWorker callback');
|
|
ok(!fs.existsSync(path.join(ROOT, 'LocalFlowPlugins/utility/copyToWorkDir/2.0.0')), 'copyToWorkDir v2.0.0 is deleted');
|
|
|
|
const replacePluginCode = require('fs').readFileSync(path.join(ROOT, 'LocalFlowPlugins/utility/replaceOriginalFile/1.0.0/index.js'), 'utf8');
|
|
ok(replacePluginCode.includes('copyWithProgress'), 'replaceOriginalFile v1 uses copyWithProgress');
|
|
ok(replacePluginCode.includes('updateWorker'), 'replaceOriginalFile v1 forwards updateWorker callback');
|
|
ok(replacePluginCode.includes('.partial.old'), 'replaceOriginalFile v1 uses a rollback backup');
|
|
ok(replacePluginCode.includes('fs.renameSync(temporary, destination)'), 'replaceOriginalFile v1 atomically installs the verified copy');
|
|
ok(!fs.existsSync(path.join(ROOT, 'LocalFlowPlugins/utility/replaceOriginalFile/2.0.0')), 'replaceOriginalFile v2.0.0 is deleted');
|
|
|
|
const copyHelperCode = require('fs').readFileSync(path.join(ROOT, 'FlowHelpers/1.0.0/copyWithProgress.js'), 'utf8');
|
|
ok(copyHelperCode.includes('MAX_RETRIES = 2'), 'copy helper retries failed writes');
|
|
ok(copyHelperCode.includes('Copy size mismatch'), 'copy helper verifies destination size');
|
|
ok(copyHelperCode.includes('fs.unlinkSync(destination)'), 'copy helper removes partial copies before retrying');
|
|
ok(copyHelperCode.includes('formatEta'), 'copy helper formats ETA');
|
|
ok(copyHelperCode.includes('updateWorker'), 'copy helper updates Tdarr worker progress');
|
|
ok(copyHelperCode.includes('PROGRESS_INTERVAL_MS = 1000'), 'copy helper reports progress every 1 second (1000ms)');
|
|
|
|
// ── Subtitle default naming checks ─────────────────────────────────────────
|
|
console.log('\n── Subtitle default naming rules ────────────────────');
|
|
const subPluginCode = require('fs').readFileSync(path.join(ROOT, 'LocalFlowPlugins/subtitles/extractSubtitlesAndOcr/1.0.0/index.js'), 'utf8');
|
|
ok(subPluginCode.includes("lang === 'ita' && isForced"), 'extractSubtitlesAndOcr: only ita.forced gets default flag');
|
|
ok(!subPluginCode.includes("if (isForced || (stream.disposition && stream.disposition.default))"), 'extractSubtitlesAndOcr: old buggy default condition removed');
|
|
|
|
const finalizeCode = require('fs').readFileSync(path.join(ROOT, 'LocalFlowPlugins/utility/finalizeMedia/1.0.0/index.js'), 'utf8');
|
|
ok(finalizeCode.includes("value === 'default'"), 'finalizeMedia: strips default before checking for ita.forced');
|
|
ok(finalizeCode.includes("isItaForced ? '.default' : ''"), 'finalizeMedia: expected subtitle sidecar only expects .default on ita.forced');
|
|
|
|
// ── Summary ───────────────────────────────────────────────────────────────
|
|
console.log(`\n${'='.repeat(55)}`);
|
|
console.log(` ${passed} passed, ${failed} failed`);
|
|
if (failed > 0) { console.error(' SOME TESTS FAILED'); process.exit(1); }
|
|
else console.log(' ALL LOGIC TESTS PASSED');
|
|
})();
|