141 lines
5.5 KiB
Go
141 lines
5.5 KiB
Go
package audio_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"git.d-ma.be/mathias/tapir/internal/adapters/audio"
|
|
)
|
|
|
|
func TestFFmpegToWAV_AsksForSixteenKilohertzMonoPCMAlways(t *testing.T) {
|
|
// Always transcode, even when the input already is 16 kHz mono: a Teams export
|
|
// often is, and the point is to not ASSUME (ADR-033). Records the argv.
|
|
rec := filepath.Join(t.TempDir(), "argv")
|
|
bin := stub(t, `printf '%s\n' "$@" > `+rec+`
|
|
for a; do last="$a"; done
|
|
printf data > "$last"`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/spool/in", filepath.Join(t.TempDir(), "out.wav"))
|
|
|
|
require.NoError(t, err)
|
|
raw, err := os.ReadFile(rec)
|
|
require.NoError(t, err)
|
|
argv := strings.Split(strings.TrimSpace(string(raw)), "\n")
|
|
joined := " " + strings.Join(argv, " ") + " "
|
|
for _, want := range []string{" -ac 1 ", " -ar 16000 ", " -c:a pcm_s16le ", " -vn ", " -i /spool/in "} {
|
|
assert.Contains(t, joined, want)
|
|
}
|
|
assert.True(t, strings.HasSuffix(strings.TrimSpace(joined), "out.wav"), "the output path is the last argument")
|
|
}
|
|
|
|
func TestFFmpegToWAV_NonzeroExitIsAnErrorCarryingStderr(t *testing.T) {
|
|
bin := stub(t, `echo "moov atom not found" >&2; exit 1`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/in", filepath.Join(t.TempDir(), "o.wav"))
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "moov atom not found")
|
|
}
|
|
|
|
func TestFFmpegToWAV_ZeroExitWithNoOutputIsAnError(t *testing.T) {
|
|
bin := stub(t, `exit 0`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/in", filepath.Join(t.TempDir(), "never-written.wav"))
|
|
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestFFmpegToWAV_MissingBinaryIsAnError(t *testing.T) {
|
|
err := (&audio.FFmpeg{Bin: filepath.Join(t.TempDir(), "no-ffmpeg")}).ToWAV(context.Background(), "/in", "/out.wav")
|
|
|
|
require.Error(t, err)
|
|
assert.False(t, errors.Is(err, context.Canceled))
|
|
}
|
|
|
|
func TestFFmpegToWAV_RestrictsWhatTheFileMayMakeFFmpegOpen(t *testing.T) {
|
|
rec := filepath.Join(t.TempDir(), "argv")
|
|
bin := stub(t, `printf '%s\n' "$@" > `+rec+`
|
|
for a; do last="$a"; done
|
|
printf data > "$last"`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/spool/in", filepath.Join(t.TempDir(), "o.wav"))
|
|
|
|
require.NoError(t, err)
|
|
args := argvOf(t, rec)
|
|
pw, fw, in := indexOf(args, "-protocol_whitelist"), indexOf(args, "-format_whitelist"), indexOf(args, "-i")
|
|
require.GreaterOrEqual(t, pw, 0, "argv: %v", args)
|
|
require.GreaterOrEqual(t, fw, 0, "argv: %v", args)
|
|
assert.Equal(t, "file,pipe", args[pw+1])
|
|
assert.Equal(t, audio.AllowedDemuxers, args[fw+1])
|
|
assert.Less(t, pw, in, "input options must come BEFORE -i or ffmpeg applies them to the output")
|
|
assert.Less(t, fw, in)
|
|
}
|
|
|
|
func TestFFmpegToWAV_PassesAnOutputLengthCapAfterTheInputWhenAMaximumIsSet(t *testing.T) {
|
|
// The duration limit is a CLAIM in the file's header; a file that lies about it can
|
|
// convert to hours of audio (adversarial review F2: a 2 h file claiming 10 s became a
|
|
// 120-minute WAV). The cap is an OUTPUT option, after -i, with a minute of slack.
|
|
rec := filepath.Join(t.TempDir(), "argv")
|
|
bin := stub(t, `printf '%s\n' "$@" > `+rec+`
|
|
for a; do last="$a"; done
|
|
printf data > "$last"`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin, MaxSeconds: 5400}).ToWAV(context.Background(), "/spool/in", filepath.Join(t.TempDir(), "out.wav"))
|
|
|
|
require.NoError(t, err)
|
|
raw, err := os.ReadFile(rec)
|
|
require.NoError(t, err)
|
|
joined := " " + strings.Join(strings.Split(strings.TrimSpace(string(raw)), "\n"), " ") + " "
|
|
assert.Contains(t, joined, " -t 5460 ", "limit plus a minute of slack")
|
|
assert.Less(t, strings.Index(joined, " -i /spool/in "), strings.Index(joined, " -t 5460 "), "-t after -i is an output cap; before it, an input one")
|
|
}
|
|
|
|
func TestFFmpegToWAV_PassesNoLengthCapWhenNoMaximumIsSet(t *testing.T) {
|
|
rec := filepath.Join(t.TempDir(), "argv")
|
|
bin := stub(t, `printf '%s\n' "$@" > `+rec+`
|
|
for a; do last="$a"; done
|
|
printf data > "$last"`)
|
|
|
|
require.NoError(t, (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/spool/in", filepath.Join(t.TempDir(), "out.wav")))
|
|
|
|
raw, err := os.ReadFile(rec)
|
|
require.NoError(t, err)
|
|
assert.NotContains(t, " "+strings.ReplaceAll(string(raw), "\n", " ")+" ", " -t ")
|
|
}
|
|
|
|
func TestFFmpegToWAV_CapsTheStreamCountBeforeTheInput(t *testing.T) {
|
|
// ffmpeg also allocated ~570 MB opening the 900-stream file (#49).
|
|
rec := filepath.Join(t.TempDir(), "argv")
|
|
bin := stub(t, `printf '%s\n' "$@" > `+rec+`
|
|
for a; do last="$a"; done
|
|
printf data > "$last"`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/spool/in", filepath.Join(t.TempDir(), "o.wav"))
|
|
|
|
require.NoError(t, err)
|
|
args := argvOf(t, rec)
|
|
ms, in := indexOf(args, "-max_streams"), indexOf(args, "-i")
|
|
require.GreaterOrEqual(t, ms, 0, "argv: %v", args)
|
|
assert.Equal(t, "32", args[ms+1])
|
|
assert.Less(t, ms, in, "an input option placed after -i is applied to the output")
|
|
}
|
|
|
|
func TestFFmpegToWAV_ABoundedPartOfAFloodingStderrIsKept(t *testing.T) {
|
|
// A hostile mp3 made ffmpeg print ~0.4 bytes of stderr per input byte (83 MB for a
|
|
// 209 MB file), all of it buffered, then copied twice into the error (#49 review).
|
|
bin := stub(t, `head -c 5000000 /dev/zero | tr '\0' 'e' >&2; exit 1`)
|
|
|
|
err := (&audio.FFmpeg{Bin: bin}).ToWAV(context.Background(), "/spool/in", filepath.Join(t.TempDir(), "o.wav"))
|
|
|
|
require.Error(t, err)
|
|
assert.Less(t, len(err.Error()), 16*1024, "the error carries a bounded head of stderr, not all of it")
|
|
assert.Contains(t, err.Error(), "eeee", "and still carries some of it")
|
|
}
|