command_test.go

// Copyright (c) Liam Stanley <liam@liam.sh>. All rights reserved. Use of
// this source code is governed by the MIT license that can be found in
// the LICENSE file.

//nolint:forbidigo
package ytdlp

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"slices"
	"sync"
	"testing"
	"time"
)

func TestMain(m *testing.M) {
	os.Setenv("YTDLP_DEBUG", "true")
	MustInstallAll(context.TODO())
	os.Exit(m.Run())
}

type testSampleFile struct {
	url       string
	name      string
	ext       string
	extractor string
}

var sampleFiles = []testSampleFile{
	{url: "https://cdn.liam.sh/github/go-ytdlp/sample-1.mp4", name: "sample-1", ext: "mp4", extractor: "generic"},
	{url: "https://cdn.liam.sh/github/go-ytdlp/sample-2.mp4", name: "sample-2", ext: "mp4", extractor: "generic"},
	{url: "https://cdn.liam.sh/github/go-ytdlp/sample-3.mp4", name: "sample-3", ext: "mp4", extractor: "generic"},
	{url: "https://cdn.liam.sh/github/go-ytdlp/sample-4.mpg", name: "sample-4", ext: "mpg", extractor: "generic"},
}

func TestCommand_hasJSONFlag(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		cmd  *Command
		want bool
	}{
		{name: "none", cmd: New(), want: false},
		{name: "DumpJSON", cmd: New().DumpJSON(), want: true},
		{name: "DumpSingleJSON", cmd: New().DumpSingleJSON(), want: true},
		{name: "PrintJSON", cmd: New().PrintJSON(), want: true},
		{name: "Print %(j)", cmd: New().Print("%(j)"), want: true},
		{name: "Print %(title)s", cmd: New().Print("%(title)s"), want: false},
		{name: "Print %(j) with extra template", cmd: New().Print("%(j)").Print("%(title)s"), want: false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			if got := tt.cmd.hasJSONFlag(); got != tt.want {
				t.Fatalf("hasJSONFlag() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCommand_BuildCommand_BunCache(t *testing.T) {
	bunResolveCache.Store(&ResolvedInstall{Executable: "bun"})
	t.Cleanup(func() {
		bunResolveCache.Store(nil)
	})

	cmd := New().
		SetExecutable("/bin/true").
		BuildCommand(context.Background())

	if !slices.Contains(cmd.Args, "--no-js-runtimes") {
		t.Fatal("expected --no-js-runtimes flag to be set")
	}
	if !slices.Contains(cmd.Args, "--js-runtimes") {
		t.Fatal("expected --js-runtimes flag to be set")
	}
	if !slices.Contains(cmd.Args, "bun") {
		t.Fatal("expected bun runtime to be enabled")
	}
}

func TestCommand_CloneExecutionSettings(t *testing.T) {
	t.Parallel()

	original := New().
		SetCancelMaxWait(2 * time.Second).
		SetEnvVarInherit(false)
	clone := original.Clone()

	if clone.cancelMaxWait != 2*time.Second {
		t.Fatalf("expected cancel max wait to be cloned, got %s", clone.cancelMaxWait)
	}
	if !clone.disableEnvVarInherit {
		t.Fatal("expected environment inheritance setting to be cloned")
	}
}

func TestFlagConfigToFlagsDeduplicatesLastFlag(t *testing.T) {
	t.Parallel()

	config := &FlagConfig{}
	config.General.IgnoreErrors = new(true)
	config.General.NoAbortOnError = new(true)
	config.General.AbortOnError = new(true)

	flags := config.ToFlags().FindByID("ignoreerrors")
	if len(flags) != 1 {
		t.Fatalf("expected one ignoreerrors flag, got %d: %#v", len(flags), flags)
	}
	if flags[0].Flag != "--abort-on-error" {
		t.Fatalf("expected the last ignoreerrors flag, got %q", flags[0].Flag)
	}
}

func TestCommand_Simple(t *testing.T) {
	t.Parallel()

	dir := t.TempDir()

	var urls []string

	for _, f := range sampleFiles {
		urls = append(urls, f.url)
	}

	progressUpdates := map[string]ProgressUpdate{}

	res, rerr := New().
		NoUpdate().
		Verbose().
		PrintJSON().
		NoProgress().
		NoOverwrites().
		Output(filepath.Join(dir, "%(extractor)s - %(title)s.%(ext)s")).
		ProgressFunc(100*time.Millisecond, func(prog ProgressUpdate) {
			progressUpdates[prog.Filename] = prog
		}).
		Run(context.Background(), urls...)
	if rerr != nil {
		t.Fatal(rerr)
	}

	if res == nil {
		t.Fatal("res is nil")
	}

	if res.ExitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", res.ExitCode)
	}

	if !slices.Contains(res.Args, "--verbose") {
		t.Fatal("expected --verbose flag to be set")
	}

	var hasJSON bool
	for _, l := range res.OutputLogs {
		if l.JSON != nil {
			hasJSON = true
			break
		}
	}

	if !hasJSON {
		t.Fatal("expected at least one log line to be valid JSON due to one of --print-json/--dump-json/--print '%()j'")
	}

	for _, f := range sampleFiles {
		t.Run(f.name, func(t *testing.T) {
			t.Parallel()

			fn := filepath.Join(dir, fmt.Sprintf("%s - %s.%s", f.extractor, f.name, f.ext))

			stat, err := os.Stat(fn)
			if err != nil {
				t.Fatal(err)
			}

			if stat.Size() == 0 {
				t.Fatal("file is empty")
			}

			prog, ok := progressUpdates[fn]
			if !ok {
				t.Fatalf("expected progress updates for %s", fn)
			}

			if prog.Finished.IsZero() || prog.Started.IsZero() {
				t.Fatal("expected progress start and finish times to be set")
			}

			if prog.TotalBytes == 0 {
				t.Fatal("expected progress total bytes to be set")
			}
			if prog.DownloadedBytes == 0 {
				t.Fatal("expected progress downloaded bytes to be set")
			}

			if prog.Percent() < 100.0 {
				t.Fatalf("expected progress to be 100%%, got %.2f%%", prog.Percent())
			}

			if prog.Info.URL == nil {
				t.Fatal("expected progress info URL to be set")
			}
		})
	}
}

func TestCommand_Version(t *testing.T) {
	t.Parallel()

	res, err := New().NoUpdate().Version(context.Background())
	if err != nil {
		t.Fatal(err)
	}

	if res == nil {
		t.Fatal("res is nil")
	}

	if res.ExitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", res.ExitCode)
	}

	_, err = time.Parse("2006.01.02", res.Stdout)
	if err != nil {
		t.Fatalf("failed to parse version: %v", err)
	}
}

func TestCommand_Unset(t *testing.T) {
	t.Parallel()

	builder := New().NoUpdate().Progress().NoProgress().Output("test.mp4")

	bunResolveCache.Store(nil) // Explicitly clear the resolve cache for bun, so it doesn't inject itself into the command.
	cmd := builder.BuildCommand(context.TODO(), sampleFiles[0].url)

	// Make sure --no-progress is set.
	if !slices.Contains(cmd.Args, "--no-progress") {
		t.Fatal("expected --no-progress flag to be set")
	}

	_ = builder.UnsetProgress()

	bunResolveCache.Store(nil) // Explicitly clear the resolve cache for bun, so it doesn't inject itself into the command.
	cmd = builder.BuildCommand(context.TODO(), sampleFiles[0].url)

	// Make sure --no-progress is not set.
	if slices.Contains(cmd.Args, "--no-progress") {
		t.Fatal("expected --no-progress flag to not be set")
	}

	// Progress and NoProgress should conflict, so arg length should be 5 (no-update, executable, output, output value, and url).
	if len(cmd.Args) != 5 {
		t.Fatalf("expected arg length to be 4, got %d: %#v", len(cmd.Args), cmd.Args)
	}
}

func TestCommand_Clone(t *testing.T) {
	t.Parallel()

	builder1 := New().NoUpdate().NoProgress().Output("test.mp4")

	builder2 := builder1.Clone()

	cmd := builder2.BuildCommand(context.TODO(), sampleFiles[0].url)

	// Make sure --no-progress is set.
	if !slices.Contains(cmd.Args, "--no-progress") {
		t.Fatal("expected --no-progress flag to be set")
	}
}

func TestCommand_SetExecutable(t *testing.T) {
	t.Parallel()

	cmd := New().NoUpdate().SetExecutable("/usr/bin/test").BuildCommand(context.Background(), sampleFiles[0].url)

	if cmd.Path != "/usr/bin/test" {
		t.Fatalf("expected executable to be /usr/bin/test, got %s", cmd.Path)
	}
}

func TestCommand_SetWorkDir(t *testing.T) {
	t.Parallel()

	cmd := New().NoUpdate().SetWorkDir("/tmp").BuildCommand(context.Background(), sampleFiles[0].url)

	if cmd.Dir != "/tmp" {
		t.Fatalf("expected workdir to be /tmp, got %s", cmd.Dir)
	}
}

func TestCommand_SetEnvVar(t *testing.T) {
	t.Parallel()

	cmd := New().NoUpdate().SetEnvVar("TEST", "1").BuildCommand(context.Background(), sampleFiles[0].url)

	if !slices.Contains(cmd.Env, "TEST=1") {
		t.Fatalf("expected env var to be TEST=1, got %v", cmd.Env)
	}
}

func TestCommand_SetFlagConfig_DuplicateFlags(t *testing.T) {
	t.Parallel()

	flagConfig := &FlagConfig{}
	flagConfig.General.IgnoreErrors = new(true)
	flagConfig.General.AbortOnError = new(true)

	builder := New().NoUpdate().SetFlagConfig(flagConfig)

	err := builder.flagConfig.General.Validate()
	if err == nil {
		t.Fatal("expected validation error, got nil")
	}

	if _, ok := IsMultipleJSONParsingFlagsError(err); !ok {
		t.Fatalf("expected validation error to be a multiple JSON parsing flags error, got %v", err)
	}
}

func TestCommand_JSONClone(t *testing.T) {
	t.Parallel()

	builder := New().NoUpdate().IgnoreErrors().Output("test.mp4")

	cloned := builder.GetFlagConfig().Clone()

	if cloned.General.IgnoreErrors == nil {
		t.Fatal("expected ignore errors to be set")
	}

	if v := cloned.Filesystem.Output; v == nil {
		t.Fatal("expected output to be set")
	}

	if *cloned.Filesystem.Output != "test.mp4" {
		t.Fatalf("expected output to be %q, got %q", "test.mp4", *cloned.Filesystem.Output)
	}
}

func TestCommand_StderrFunc(t *testing.T) {
	t.Parallel()

	server := newMockServer(t, "testdata/sample-1.mp4")

	dir := t.TempDir()

	var mu sync.Mutex
	var stderrLines []string

	result, err := New().
		Verbose().
		ForceOverwrites().
		Output(filepath.Join(dir, "%(extractor)s - %(title)s.%(ext)s")).
		StderrFunc(func(line string) { //nolint:staticcheck // testing deprecated alias
			mu.Lock()
			stderrLines = append(stderrLines, line)
			mu.Unlock()
		}).
		Run(context.TODO(), server.fileURL)
	if err != nil {
		t.Fatal(err)
	}

	if result.ExitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", result.ExitCode)
	}

	mu.Lock()
	count := len(stderrLines)
	mu.Unlock()

	if count == 0 {
		t.Fatal("expected at least one stderr line from the callback")
	}

	if result.Stderr == "" {
		t.Fatal("expected result.Stderr to be non-empty with --verbose")
	}
}

func TestCommand_StderrFuncFiltersStdout(t *testing.T) {
	t.Parallel()

	var got []string
	cmd := New().LogFunc(func(log *ResultLog) {
		if log.Pipe == "stderr" {
			StderrCallbackFunc(func(line string) { got = append(got, line) })(log.Line)
		}
	})

	cmd.log(&ResultLog{Pipe: PipeStdout, Line: "out"})
	cmd.log(&ResultLog{Pipe: PipeStderr, Line: "err"})

	if len(got) != 1 || got[0] != "err" {
		t.Fatalf("got %v, want [err]", got)
	}
}

func TestCommand_StderrFunc_Clone(t *testing.T) {
	t.Parallel()

	called := false
	builder := New().NoUpdate().StderrFunc(func(_ string) { //nolint:staticcheck // testing deprecated alias
		called = true
	})

	cloned := builder.Clone()
	if cloned.log == nil {
		t.Fatal("expected log handler to be copied by Clone()")
	}

	cloned.log(&ResultLog{Pipe: PipeStderr, Line: "test"})
	if !called {
		t.Fatal("expected cloned stderr handler to invoke the original callback")
	}

	called = false
	cloned.log(&ResultLog{Pipe: PipeStdout, Line: "test"})
	if called {
		t.Fatal("stderr handler should ignore stdout")
	}
}

func TestCommand_UnsetStderrFunc(t *testing.T) {
	t.Parallel()

	builder := New().NoUpdate().LogFunc(func(log *ResultLog) {
		if log.Pipe == "stderr" {
			StderrCallbackFunc(func(_ string) {})(log.Line)
		}
	}).UnsetStderrFunc() //nolint:staticcheck // testing deprecated alias

	if builder.log != nil {
		t.Fatal("expected log handler to be nil after UnsetStderrFunc()")
	}
}

func TestCommand_LogFunc_Clone(t *testing.T) {
	t.Parallel()

	called := false
	builder := New().NoUpdate().LogFunc(func(_ *ResultLog) {
		called = true
	})

	cloned := builder.Clone()
	if cloned.log == nil {
		t.Fatal("expected log handler to be copied by Clone()")
	}

	cloned.log(&ResultLog{Line: "test"})
	if !called {
		t.Fatal("expected cloned log handler to invoke the original callback")
	}
}

func TestCommand_UnsetLogFunc(t *testing.T) {
	t.Parallel()

	builder := New().NoUpdate().LogFunc(func(_ *ResultLog) {}).UnsetLogFunc()
	if builder.log != nil {
		t.Fatal("expected log handler to be nil after UnsetLogFunc()")
	}
}

func TestCommand_ExtractInfoDoesNotMutate(t *testing.T) {
	t.Parallel()

	cmd := New().NoUpdate().SetExecutable("/nonexistent-ytdlp")
	_, _, _ = cmd.ExtractInfo(t.Context(), "https://example.com/video")

	cfg := cmd.GetFlagConfig()
	if cfg.VerbositySimulation.SkipDownload != nil {
		t.Fatal("ExtractInfo mutated SkipDownload")
	}
	if cfg.VerbositySimulation.DumpJSON != nil {
		t.Fatal("ExtractInfo mutated DumpJSON")
	}
}

func TestCommand_RunWithInfoDoesNotMutate(t *testing.T) {
	t.Parallel()

	cmd := New().NoUpdate().SetExecutable("/nonexistent-ytdlp")
	_, _ = cmd.RunWithInfo(t.Context(), []*ExtractedInfo{{
		ID:    "sample-1",
		Type:  ExtractedTypeVideo,
		Title: new("sample-1"),
	}})

	if cmd.GetFlagConfig().Filesystem.LoadInfoJSON != nil {
		t.Fatal("RunWithInfo mutated LoadInfoJSON")
	}
}

func TestCommand_RunWithInfoEmpty(t *testing.T) {
	t.Parallel()

	_, err := New().RunWithInfo(t.Context(), nil)
	if err == nil {
		t.Fatal("expected error")
	}
}

func TestCommand_LogFunc(t *testing.T) {
	t.Parallel()

	server := newMockServer(t, "testdata/sample-1.mp4")
	dir := t.TempDir()

	var mu sync.Mutex
	var logs []*ResultLog

	result, err := New().
		Verbose().
		ForceOverwrites().
		Output(filepath.Join(dir, "%(extractor)s - %(title)s.%(ext)s")).
		LogFunc(func(log *ResultLog) {
			mu.Lock()
			logs = append(logs, log)
			mu.Unlock()
		}).
		Run(t.Context(), server.fileURL)
	if err != nil {
		t.Fatal(err)
	}
	if result.ExitCode != 0 {
		t.Fatalf("expected exit code 0, got %d", result.ExitCode)
	}

	mu.Lock()
	defer mu.Unlock()
	if len(logs) == 0 {
		t.Fatal("expected at least one log line from the callback")
	}
}

func TestCommand_ExtractInfo(t *testing.T) {
	t.Parallel()

	server := newMockServer(t, "testdata/sample-1.mp4")
	info, result, err := New().NoUpdate().ExtractInfo(t.Context(), server.fileURL)
	if err != nil {
		t.Fatal(err)
	}
	if result.ExitCode != 0 {
		t.Fatalf("exit code = %d, want 0", result.ExitCode)
	}
	if len(info) != 1 || info[0].ID != "sample-1" {
		t.Fatalf("info = %+v, want sample-1", idsOf(info))
	}
	if info[0].Type != ExtractedTypeVideo && info[0].Type != ExtractedTypeSingle && info[0].Type != "" {
		t.Fatalf("type = %q", info[0].Type)
	}
}

func TestCommand_RunWithInfo(t *testing.T) {
	t.Parallel()

	server := newMockServer(t, "testdata/sample-1.mp4")
	info, _, err := New().NoUpdate().ExtractInfo(t.Context(), server.fileURL)
	if err != nil {
		t.Fatal(err)
	}

	dir := t.TempDir()
	result, err := New().
		NoUpdate().
		ForceOverwrites().
		Output(filepath.Join(dir, "%(extractor)s - %(title)s.%(ext)s")).
		RunWithInfo(t.Context(), info)
	if err != nil {
		t.Fatal(err)
	}
	if result.ExitCode != 0 {
		t.Fatalf("exit code = %d, want 0", result.ExitCode)
	}

	matches, err := filepath.Glob(filepath.Join(dir, "*"))
	if err != nil {
		t.Fatal(err)
	}
	if len(matches) == 0 {
		t.Fatal("expected a downloaded file")
	}
}