add unit test, using DI to stub out FFmpeg invocation

Author: hheimbuerger

hlsvod/manager.go

@@ -24,6 +24,10 @@ const readyTimeout = 80 * time.Second
 // how long can it take for transcode to return first data
 const transcodeTimeout = 10 * time.Second
 
+// transcodeSegmentsFn is a package-level hook so tests can stub out the actual
+// FFmpeg-based implementation. In production it points to TranscodeSegments.
+var transcodeSegmentsFn = TranscodeSegments
+
 type ManagerCtx struct {
 	mu     sync.Mutex
 	logger zerolog.Logger
@@ -382,7 +386,7 @@ func (m *ManagerCtx) transcodeSegments(offset, limit int) error {
 	segmentTimes := m.breakpoints[offset : offset+limit+1]
 	logger.Info().Interface("segments-times", segmentTimes).Msg("transcoding segments")
 
-	segments, err := TranscodeSegments(m.ctx, m.config.FFmpegBinary, TranscodeConfig{
+	segments, err := transcodeSegmentsFn(m.ctx, m.config.FFmpegBinary, TranscodeConfig{
 		InputFilePath: m.config.MediaPath,
 		OutputDirPath: m.config.TranscodeDir,
 		SegmentPrefix: m.config.SegmentPrefix, // This does not need to match.

hlsvod/manager_test.go

@@ -0,0 +1,47 @@
+package hlsvod
+
+import (
+	"context"
+	"testing"
+)
+
+// TestTranscodeFromSegmentBufferSize ensures that transcodeFromSegment()
+// queues exactly segmentBufferMax segments for transcoding. At the moment
+// the implementation appears to queue only segmentBufferMax-1 segments,
+// so this test is expected to FAIL until the bug is fixed.
+func TestTranscodeFromSegmentBufferSize(t *testing.T) {
+	const bufferMax = 5
+
+	// Prepare a ManagerCtx with exactly bufferMax segments.
+	m := &ManagerCtx{
+		breakpoints:      make([]float64, bufferMax+1),
+		segmentBufferMax: bufferMax,
+		segmentBufferMin: 3, // default value from constructor
+		segments:         make(map[int]string),
+		segmentQueue:     make(map[int]chan struct{}),
+	}
+
+	// Populate the dummy segments map so that len(m.segments) == bufferMax.
+	for i := 0; i < bufferMax; i++ {
+		m.segments[i] = ""
+	}
+
+	// Stub out the transcode function so the test doesn't invoke FFmpeg.
+	origFn := transcodeSegmentsFn
+	transcodeSegmentsFn = func(_ context.Context, _ string, _ TranscodeConfig) (chan string, error) {
+		ch := make(chan string)
+		close(ch)
+		return ch, nil
+	}
+	defer func() { transcodeSegmentsFn = origFn }()
+
+	// Execute the code under test.
+	if err := m.transcodeFromSegment(0); err != nil {
+		t.Fatalf("transcodeFromSegment returned error: %v", err)
+	}
+
+	// transcodeFromSegment should enqueue `bufferMax` segments
+	if got := len(m.segmentQueue); got != bufferMax {
+		t.Fatalf("expected %d queued segments, got %d", bufferMax, got)
+	}
+}