task_test.go

package task_test

import (
	"archive/zip"
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"maps"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"slices"
	"sort"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/Masterminds/semver/v3"
	"github.com/sebdah/goldie/v2"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/wallix/task/v3"
	"github.com/wallix/task/v3/errors"
	"github.com/wallix/task/v3/experiments"
	"github.com/wallix/task/v3/internal/filepathext"
	"github.com/wallix/task/v3/taskfile/ast"
)

func init() {
	_ = os.Setenv("NO_COLOR", "1")
}

type (
	TestOption interface {
		ExecutorTestOption
		FormatterTestOption
	}
	TaskTest struct {
		name                     string
		experiments              map[*experiments.Experiment]int
		postProcessFns           []PostProcessFn
		fixtureTemplateData      map[string]any
		fixtureTemplatingEnabled bool
	}
)

// goldenFileName makes the file path for fixture files safe for all well-known
// operating systems. Windows in particular has a lot of restrictions the
// characters that can be used in file paths.
func goldenFileName(t *testing.T) string {
	t.Helper()
	name := t.Name()
	for _, c := range []string{` `, `<`, `>`, `:`, `"`, `/`, `\`, `|`, `?`, `*`} {
		name = strings.ReplaceAll(name, c, "-")
	}
	return name
}

// writeFixture writes a fixture file for the test. The fixture file is created
// using the [goldie.Goldie] package. The fixture file is created with the
// output of the task, after any post-process functions have been applied.
func (tt *TaskTest) writeFixture(
	t *testing.T,
	g *goldie.Goldie,
	goldenFileSuffix string,
	b []byte,
) {
	t.Helper()
	// Apply any post-process functions
	for _, fn := range tt.postProcessFns {
		b = fn(t, b)
	}
	// Write the fixture file
	goldenFileName := goldenFileName(t)
	if goldenFileSuffix != "" {
		goldenFileName += "-" + goldenFileSuffix
	}
	// Create a set of data to be made available to every test fixture
	wd, err := os.Getwd()
	require.NoError(t, err)
	if tt.fixtureTemplatingEnabled {
		fixtureTemplateData := map[string]any{
			"TEST_NAME": t.Name(),
			"TEST_DIR":  wd,
		}
		// If the test has additional template data, copy it into the map
		if tt.fixtureTemplateData != nil {
			maps.Copy(fixtureTemplateData, tt.fixtureTemplateData)
		}
		g.AssertWithTemplate(t, goldenFileName, fixtureTemplateData, b)
	} else {
		g.Assert(t, goldenFileName, b)
	}
}

// writeFixtureBuffer is a wrapper for writing the main output of the task to a
// fixture file.
func (tt *TaskTest) writeFixtureBuffer(
	t *testing.T,
	g *goldie.Goldie,
	buff bytes.Buffer,
) {
	t.Helper()
	tt.writeFixture(t, g, "", buff.Bytes())
}

// writeFixtureErrSetup is a wrapper for writing the output of an error during
// the setup phase of the task to a fixture file.
func (tt *TaskTest) writeFixtureErrSetup(
	t *testing.T,
	g *goldie.Goldie,
	err error,
) {
	t.Helper()
	tt.writeFixture(t, g, "err-setup", []byte(err.Error()))
}

// Functional options

// WithName gives the test fixture output a name. This should be used when
// running multiple tests in a single test function.
func WithName(name string) TestOption {
	return &nameTestOption{name: name}
}

type nameTestOption struct {
	name string
}

func (opt *nameTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.name = opt.name
}

func (opt *nameTestOption) applyToFormatterTest(t *FormatterTest) {
	t.name = opt.name
}

// WithTask sets the name of the task to run. This should be used when the task
// to run is not the default task.
func WithTask(task string) TestOption {
	return &taskTestOption{task: task}
}

type taskTestOption struct {
	task string
}

func (opt *taskTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.task = opt.task
}

func (opt *taskTestOption) applyToFormatterTest(t *FormatterTest) {
	t.task = opt.task
}

// WithVar sets a variable to be passed to the task. This can be called multiple
// times to set more than one variable.
func WithVar(key string, value any) TestOption {
	return &varTestOption{key: key, value: value}
}

type varTestOption struct {
	key   string
	value any
}

func (opt *varTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.vars[opt.key] = opt.value
}

func (opt *varTestOption) applyToFormatterTest(t *FormatterTest) {
	t.vars[opt.key] = opt.value
}

// WithExecutorOptions sets the [task.ExecutorOption]s to be used when creating
// a [task.Executor].
func WithExecutorOptions(executorOpts ...task.ExecutorOption) TestOption {
	return &executorOptionsTestOption{executorOpts: executorOpts}
}

type executorOptionsTestOption struct {
	executorOpts []task.ExecutorOption
}

func (opt *executorOptionsTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.executorOpts = slices.Concat(t.executorOpts, opt.executorOpts)
}

func (opt *executorOptionsTestOption) applyToFormatterTest(t *FormatterTest) {
	t.executorOpts = slices.Concat(t.executorOpts, opt.executorOpts)
}

// WithExperiment sets an experiment to be enabled for the test. This can be
// called multiple times to enable more than one experiment.
func WithExperiment(experiment *experiments.Experiment, value int) TestOption {
	return &experimentTestOption{experiment: experiment, value: value}
}

type experimentTestOption struct {
	experiment *experiments.Experiment
	value      int
}

func (opt *experimentTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.experiments[opt.experiment] = opt.value
}

func (opt *experimentTestOption) applyToFormatterTest(t *FormatterTest) {
	t.experiments[opt.experiment] = opt.value
}

// WithPostProcessFn adds a [PostProcessFn] function to the test. Post-process
// functions are run on the output of the task before a fixture is created. This
// can be used to remove absolute paths, sort lines, etc. This can be called
// multiple times to add more than one post-process function.
func WithPostProcessFn(fn PostProcessFn) TestOption {
	return &postProcessFnTestOption{fn: fn}
}

type postProcessFnTestOption struct {
	fn PostProcessFn
}

func (opt *postProcessFnTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.postProcessFns = append(t.postProcessFns, opt.fn)
}

func (opt *postProcessFnTestOption) applyToFormatterTest(t *FormatterTest) {
	t.postProcessFns = append(t.postProcessFns, opt.fn)
}

// WithSetupError sets the test to expect an error during the setup phase of the
// task execution. A fixture will be created with the output of any errors.
func WithSetupError() TestOption {
	return &setupErrorTestOption{}
}

type setupErrorTestOption struct{}

func (opt *setupErrorTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.wantSetupError = true
}

func (opt *setupErrorTestOption) applyToFormatterTest(t *FormatterTest) {
	t.wantSetupError = true
}

// WithFixtureTemplating enables templating for the golden fixture files with
// the default set of data. This is useful if the golden file is dynamic in some
// way (e.g. contains user-specific directories). To add more data, see
// WithFixtureTemplateData.
func WithFixtureTemplating() TestOption {
	return &fixtureTemplatingTestOption{}
}

type fixtureTemplatingTestOption struct{}

func (opt *fixtureTemplatingTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.fixtureTemplatingEnabled = true
}

func (opt *fixtureTemplatingTestOption) applyToFormatterTest(t *FormatterTest) {
	t.fixtureTemplatingEnabled = true
}

// WithFixtureTemplateData adds data to the golden fixture file templates. Keys
// given here will override any existing values. This option will also enable
// global templating, so you do not need to call WithFixtureTemplating as well.
func WithFixtureTemplateData(key string, value any) TestOption {
	return &fixtureTemplateDataTestOption{key, value}
}

type fixtureTemplateDataTestOption struct {
	k string
	v any
}

func (opt *fixtureTemplateDataTestOption) applyToExecutorTest(t *ExecutorTest) {
	t.fixtureTemplatingEnabled = true
	t.fixtureTemplateData[opt.k] = opt.v
}

func (opt *fixtureTemplateDataTestOption) applyToFormatterTest(t *FormatterTest) {
	t.fixtureTemplatingEnabled = true
	t.fixtureTemplateData[opt.k] = opt.v
}

// Post-processing

// A PostProcessFn is a function that can be applied to the output of a test
// fixture before the file is written.
type PostProcessFn func(*testing.T, []byte) []byte

// PPSortedLines sorts the lines of the output of the task. This is useful when
// the order of the output is not important, but the output is expected to be
// the same each time the task is run (e.g. when running tasks in parallel).
func PPSortedLines(t *testing.T, b []byte) []byte {
	t.Helper()
	lines := strings.Split(strings.TrimSpace(string(b)), "\n")
	sort.Strings(lines)
	return []byte(strings.Join(lines, "\n") + "\n")
}

// SyncBuffer is a threadsafe buffer for testing.
// Some times replace stdout/stderr with a buffer to capture output.
// stdout and stderr are threadsafe, but a regular bytes.Buffer is not.
// Using this instead helps prevents race conditions with output.
type SyncBuffer struct {
	buf bytes.Buffer
	mu  sync.Mutex
}

func (sb *SyncBuffer) Write(p []byte) (n int, err error) {
	sb.mu.Lock()
	defer sb.mu.Unlock()
	return sb.buf.Write(p)
}

// fileContentTest provides a basic reusable test-case for running a Taskfile
// and inspect generated files.
type fileContentTest struct {
	Dir        string
	Entrypoint string
	Target     string
	TrimSpace  bool
	Files      map[string]string
}

func (fct fileContentTest) name(file string) string {
	return fmt.Sprintf("target=%q,file=%q", fct.Target, file)
}

func (fct fileContentTest) Run(t *testing.T) {
	t.Helper()

	for f := range fct.Files {
		_ = os.Remove(filepathext.SmartJoin(fct.Dir, f))
	}

	e := task.NewExecutor(
		task.WithDir(fct.Dir),
		task.WithTempDir(task.TempDir{
			Fingerprint: filepathext.SmartJoin(fct.Dir, ".task"),
		}),
		task.WithEntrypoint(fct.Entrypoint),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
	)

	require.NoError(t, e.Setup(), "e.Setup()")
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: fct.Target}), "e.Run(target)")
	for name, expectContent := range fct.Files {
		t.Run(fct.name(name), func(t *testing.T) {
			path := filepathext.SmartJoin(e.Dir, name)
			b, err := os.ReadFile(path)
			require.NoError(t, err, "Error reading file")
			s := string(b)
			if fct.TrimSpace {
				s = strings.TrimSpace(s)
			}
			assert.Equal(t, expectContent, s, "unexpected file content in %s", path)
		})
	}
}

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

	const dir = "testdata/generates"

	const (
		srcTask        = "sub/src.txt"
		relTask        = "rel.txt"
		absTask        = "abs.txt"
		fileWithSpaces = "my text file.txt"
	)

	srcFile := filepathext.SmartJoin(dir, srcTask)

	for _, task := range []string{srcTask, relTask, absTask, fileWithSpaces} {
		path := filepathext.SmartJoin(dir, task)
		_ = os.Remove(path)
		if _, err := os.Stat(path); err == nil {
			t.Errorf("File should not exist: %v", err)
		}
	}

	buff := bytes.NewBuffer(nil)
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(buff),
		task.WithStderr(buff),
	)
	require.NoError(t, e.Setup())

	for _, theTask := range []string{relTask, absTask, fileWithSpaces} {
		destFile := filepathext.SmartJoin(dir, theTask)
		upToDate := fmt.Sprintf("task: Task \"%s\" is up to date\n", theTask)

		// Run task for the first time.
		require.NoError(t, e.Run(t.Context(), &task.Call{Task: theTask}))

		if _, err := os.Stat(srcFile); err != nil {
			t.Errorf("File should exist: %v", err)
		}
		if _, err := os.Stat(destFile); err != nil {
			t.Errorf("File should exist: %v", err)
		}
		// Ensure task was not incorrectly found to be up-to-date on first run.
		if buff.String() == upToDate {
			t.Errorf("Wrong output message: %s", buff.String())
		}
		buff.Reset()

		// Re-run task to ensure it's now found to be up-to-date.
		require.NoError(t, e.Run(t.Context(), &task.Call{Task: theTask}))
		assert.Contains(t, buff.String(), upToDate)
		buff.Reset()
	}
}

func TestStatusChecksum(t *testing.T) { // nolint:paralleltest // cannot run in parallel
	const dir = "testdata/checksum"

	tests := []struct {
		files []string
		task  string
	}{
		{[]string{"generated.txt", ".task/checksum/build"}, "build"},
		{[]string{"generated-wildcard.txt", ".task/checksum/build-wildcard"}, "build-wildcard"},
		{[]string{"generated.txt", ".task/checksum/build-with-status"}, "build-with-status"},
	}

	for _, test := range tests { // nolint:paralleltest // cannot run in parallel
		t.Run(test.task, func(t *testing.T) {
			for _, f := range test.files {
				_ = os.Remove(filepathext.SmartJoin(dir, f))

				_, err := os.Stat(filepathext.SmartJoin(dir, f))
				require.Error(t, err)
			}

			var buff bytes.Buffer
			tempDir := task.TempDir{
				Fingerprint: filepathext.SmartJoin(dir, ".task"),
			}
			e := task.NewExecutor(
				task.WithDir(dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithTempDir(tempDir),
			)
			require.NoError(t, e.Setup())

			require.NoError(t, e.Run(t.Context(), &task.Call{Task: test.task}))
			for _, f := range test.files {
				_, err := os.Stat(filepathext.SmartJoin(dir, f))
				require.NoError(t, err)
			}

			// Capture the modification time, so we can ensure the checksum file
			// is not regenerated when the hash hasn't changed.
			s, err := os.Stat(filepathext.SmartJoin(tempDir.Fingerprint, "checksum/"+test.task))
			require.NoError(t, err)
			time := s.ModTime()

			buff.Reset()
			require.NoError(t, e.Run(t.Context(), &task.Call{Task: test.task}))
			assert.Equal(t, `task: Task "`+test.task+`" is up to date`+"\n", buff.String())

			s, err = os.Stat(filepathext.SmartJoin(tempDir.Fingerprint, "checksum/"+test.task))
			require.NoError(t, err)
			assert.Equal(t, time, s.ModTime())
		})
	}
}

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

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    cmds:
      - cp source.txt generated.txt
    sources:
      - source.txt
    generates:
      - generated.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Before running: task should not be up to date
	require.NoError(t, e.Status(&task.Call{Task: "build"}))
	out := buff.String()
	assert.Contains(t, out, "is not up to date")
	assert.Contains(t, out, "sources: changed")
	assert.Contains(t, out, "generates: changed")
	assert.Contains(t, out, "srcrule:")
	assert.Contains(t, out, "file:")

	// Run the task
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// After running: both sources and generates should be up to date
	buff.Reset()
	require.NoError(t, e.Status(&task.Call{Task: "build"}))
	out = buff.String()
	assert.Contains(t, out, "is up to date")
	assert.Contains(t, out, "sources: up to date")
	assert.Contains(t, out, "generates: up to date")
}

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

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    cmds:
      - cp source.txt generated.txt
    sources:
      - source.txt
    generates:
      - generated.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Before running
	require.NoError(t, e.StatusJSON(&task.Call{Task: "build"}))
	var result []map[string]any
	require.NoError(t, json.Unmarshal(buff.Bytes(), &result))
	require.Len(t, result, 1)
	assert.Equal(t, "build", result[0]["task"])
	assert.Equal(t, false, result[0]["up_to_date"])
	assert.Equal(t, false, result[0]["sources_up_to_date"])
	assert.Equal(t, false, result[0]["generates_up_to_date"])
	assert.NotEmpty(t, result[0]["checksum_file"])
	assert.NotEmpty(t, result[0]["source_data"])

	// Run the task
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// After running
	buff.Reset()
	require.NoError(t, e.StatusJSON(&task.Call{Task: "build"}))
	require.NoError(t, json.Unmarshal(buff.Bytes(), &result))
	assert.Equal(t, true, result[0]["up_to_date"])
	assert.Equal(t, true, result[0]["sources_up_to_date"])
	assert.Equal(t, true, result[0]["generates_up_to_date"])
	assert.NotEmpty(t, result[0]["sources_hash"])
	assert.NotEmpty(t, result[0]["generates_hash"])
}

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

	const dir = "testdata/vars"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{
			Fingerprint: filepathext.SmartJoin(dir, ".task"),
		}),
	)
	require.NoError(t, e.Setup())

	buff.Reset()
	require.NoError(t, e.Status(&task.Call{Task: "default"}))
	assert.Contains(t, buff.String(), "has no sources or generates")
}

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

	// Regression test: when an included taskfile uses dir: "{{.SOME_VAR}}"
	// where the var resolves to an absolute path, the compiled task dir
	// must be that absolute path — not include.Dir prefixed to it.
	//
	// Before the fix, SmartJoin ran at merge time on the un-templated
	// "{{.TARGET_DIR}}" string (not recognized as absolute), producing
	// "/root/{{.TARGET_DIR}}". After template resolution this became
	// "/root//abs/target" — a doubled path.
	dir := t.TempDir()
	subDir := filepath.Join(dir, "sub")
	targetDir := filepath.Join(dir, "target")
	require.NoError(t, os.MkdirAll(subDir, 0o755))
	require.NoError(t, os.MkdirAll(targetDir, 0o755))

	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
includes:
  sub:
    taskfile: ./sub/Taskfile.yml
    internal: true
`), 0o644))

	require.NoError(t, os.WriteFile(filepath.Join(subDir, "Taskfile.yml"), []byte(fmt.Sprintf(`version: '3'
vars:
  TARGET_DIR: '%s'
tasks:
  build:
    dir: "{{.TARGET_DIR}}"
    cmds:
      - echo ok
`, targetDir)), 0o644))

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{
			Fingerprint: filepath.Join(dir, ".task"),
		}),
	)
	require.NoError(t, e.Setup())

	compiled, err := e.CompiledTask(&task.Call{Task: "sub:build"})
	require.NoError(t, err)
	assert.Equal(t, targetDir, compiled.ComputeDir())
}

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

	// Setup tasks run unconditionally before fingerprint checking.
	// This test verifies that a setup task modifies a source file,
	// causing the main task to see it as changed and re-run.
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "version.txt"), []byte("v1"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  enforce-version:
    cmds:
      - echo "v2" > version.txt

  build:
    setup:
      - enforce-version
    sources:
      - version.txt
    cmds:
      - cp version.txt output.txt
    generates:
      - output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// First run: setup modifies version.txt, then build runs
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	output, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	assert.Contains(t, string(output), "v2", "setup should have updated version.txt before build ran")

	// Second run: setup runs again (unconditionally), modifies version.txt
	// again, but since content is same, fingerprint should show up-to-date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), "up to date")
}

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

	// Even when the main task is up-to-date, setup tasks must still run.
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  track:
    cmds:
      - echo "setup-ran" >> setup.log

  build:
    setup:
      - track
    sources:
      - source.txt
    cmds:
      - cp source.txt output.txt
    generates:
      - output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// First run
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Second run: task is up-to-date, but setup should still run
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	log, err := os.ReadFile(filepath.Join(dir, "setup.log"))
	require.NoError(t, err)
	lines := strings.Split(strings.TrimSpace(string(log)), "\n")
	assert.Equal(t, 2, len(lines), "setup should have run twice (once per invocation), got: %s", string(log))
}

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

	// Setup task sources/generates are NOT merged into the parent's
	// fingerprint. Changing a setup task's source should not cause
	// the parent to rebuild.
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "version.txt"), []byte("v1"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  enforce-version:
    sources:
      - version.txt
    generates:
      - resolved-version.txt
    cmds:
      - cp version.txt resolved-version.txt

  build:
    setup:
      - enforce-version
    sources:
      - source.txt
    cmds:
      - cat source.txt resolved-version.txt > output.txt
    generates:
      - output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// First run: both setup and build execute
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	output, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	assert.Contains(t, string(output), "v1")

	// Second run: everything up-to-date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), "up to date")

	// Change version.txt (setup task's source) — parent's own source.txt is unchanged.
	// Parent should remain up-to-date since setup sources are not merged.
	require.NoError(t, os.WriteFile(filepath.Join(dir, "version.txt"), []byte("v2"), 0o644))

	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), `Task "build" is up to date`,
		"parent should stay up-to-date when only setup source changes")
}

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

	// Create a project with two tasks: a leaf and a parent that depends on it
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    sources:
      - input.txt
    generates:
      - output.txt
    cmds:
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Run the task so it becomes up-to-date
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Export cache
	cacheFile := filepath.Join(t.TempDir(), "cache.zip")
	require.NoError(t, e.ExportCache(cacheFile, &task.Call{Task: "build"}))
	assert.FileExists(t, cacheFile)

	// Delete the generated file and checksum dir
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Task should NOT be up-to-date now
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())

	// Import cache
	require.NoError(t, e2.ImportCache(cacheFile, &task.Call{Task: "build"}))

	// The generated file should be restored
	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	content, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	assert.Equal(t, "hello", string(content))

	// Task should now be up-to-date (checksums restored)
	buff.Reset()
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), "up to date")
}

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

	// Export should skip tasks that are not up-to-date
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    sources:
      - input.txt
    generates:
      - output.txt
    cmds:
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Don't run the task — it's never been run, so not up-to-date
	cacheFile := filepath.Join(t.TempDir(), "cache.zip")
	require.NoError(t, e.ExportCache(cacheFile, &task.Call{Task: "build"}))

	// Cache file should NOT be created (no up-to-date tasks)
	_, err := os.Stat(cacheFile)
	assert.True(t, os.IsNotExist(err), "cache file should not exist when no tasks are up-to-date")
}

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

	// Exporting twice without changes should detect the archive is unmodified
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    sources:
      - input.txt
    generates:
      - output.txt
    cmds:
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	cacheFile := filepath.Join(t.TempDir(), "cache.zip")

	// First export
	buff.Reset()
	require.NoError(t, e.ExportCache(cacheFile, &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), "exporting cache")

	// Second export — should detect unmodified
	buff.Reset()
	require.NoError(t, e.ExportCache(cacheFile, &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), "unmodified")
}

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

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    generates:
      - output.txt
    cmds:
      - echo hello > output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")

	run := func() {
		var buff bytes.Buffer
		e := task.NewExecutor(
			task.WithDir(dir),
			task.WithStdout(&buff),
			task.WithStderr(&buff),
			task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
		)
		require.NoError(t, e.Setup())
		require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
		assert.FileExists(t, filepath.Join(dir, "output.txt"))
	}

	// Tasks with generates but no sources have no fingerprint baseline,
	// so they always execute — even on the second run.
	run()
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	run()
}

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

	const dir = "testdata/cmds_vars"

	_ = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithTempDir(task.TempDir{
			Fingerprint: filepathext.SmartJoin(dir, ".task"),
		}),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(false),
		task.WithVerbose(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build-checksum"}))

	assert.Contains(t, buff.String(), "44f88b429595ccb250265c2d1eca60a0")
}

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

	const dir = "testdata/cyclic"

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
	)
	require.NoError(t, e.Setup())
	err := e.Run(t.Context(), &task.Call{Task: "task-1"})
	var taskCalledTooManyTimesError *errors.TaskCalledTooManyTimesError
	assert.ErrorAs(t, err, &taskCalledTooManyTimesError)
}

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

	tests := []struct {
		Dir     string
		Version *semver.Version
		wantErr bool
	}{
		{"testdata/version/v1", semver.MustParse("1"), true},
		{"testdata/version/v2", semver.MustParse("2"), true},
		{"testdata/version/v3", semver.MustParse("3"), false},
	}

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

			e := task.NewExecutor(
				task.WithDir(test.Dir),
				task.WithStdout(io.Discard),
				task.WithStderr(io.Discard),
				task.WithVersionCheck(true),
			)
			err := e.Setup()
			if test.wantErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, test.Version, e.Taskfile.Version)
			assert.Equal(t, 2, e.Taskfile.Tasks.Len())
		})
	}
}

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

	const dir = "testdata/ignore_errors"

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
	)
	require.NoError(t, e.Setup())

	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "task-should-pass"}))
	require.Error(t, e.Run(t.Context(), &task.Call{Task: "task-should-fail"}))
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "cmd-should-pass"}))
	require.Error(t, e.Run(t.Context(), &task.Call{Task: "cmd-should-fail"}))
}

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

	const dir = "testdata/expand"

	home, err := os.UserHomeDir()
	if err != nil {
		t.Errorf("Couldn't get $HOME: %v", err)
	}
	var buff bytes.Buffer

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "pwd"}))
	assert.Equal(t, home, strings.TrimSpace(buff.String()))
}

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

	const dir = "testdata/dry"

	file := filepathext.SmartJoin(dir, "file.txt")
	_ = os.Remove(file)

	var buff bytes.Buffer

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithDry(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	assert.Equal(t, "task: [build] touch file.txt", strings.TrimSpace(buff.String()))
	if _, err := os.Stat(file); err == nil {
		t.Errorf("File should not exist %s", file)
	}
}

// TestDryChecksum tests if the checksum file is not being written to disk
// if the dry mode is enabled.
func TestDryChecksum(t *testing.T) {
	t.Parallel()

	const dir = "testdata/dry_checksum"

	checksumFile := filepathext.SmartJoin(dir, ".task/checksum/default")
	_ = os.Remove(checksumFile)

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithTempDir(task.TempDir{
			Fingerprint: filepathext.SmartJoin(dir, ".task"),
		}),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
		task.WithDry(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))

	_, err := os.Stat(checksumFile)
	require.Error(t, err, "checksum file should not exist")

	e.Dry = false
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))
	_, err = os.Stat(checksumFile)
	require.NoError(t, err, "checksum file should exist")
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes",
		Target:    "default",
		TrimSpace: true,
		Files: map[string]string{
			"main.txt":                                  "main",
			"included_directory.txt":                    "included_directory",
			"included_directory_without_dir.txt":        "included_directory_without_dir",
			"included_taskfile_without_dir.txt":         "included_taskfile_without_dir",
			"./module2/included_directory_with_dir.txt": "included_directory_with_dir",
			"./module2/included_taskfile_with_dir.txt":  "included_taskfile_with_dir",
			"os_include.txt":                            "os",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_multi_level",
		Target:    "default",
		TrimSpace: true,
		Files: map[string]string{
			"called_one.txt":   "one",
			"called_two.txt":   "two",
			"called_three.txt": "three",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	const dir = "testdata/includes_cycle"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(true),
	)

	err := e.Setup()
	require.Error(t, err)
	assert.Contains(t, err.Error(), "task: include cycle detected between")
}

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

	const dir = "testdata/includes_incorrect"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(true),
	)

	err := e.Setup()
	require.Error(t, err)
	assert.Contains(t, err.Error(), "Failed to parse testdata/includes_incorrect/incomplete.yml:", err.Error())
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_empty",
		Target:    "included:default",
		TrimSpace: true,
		Files: map[string]string{
			"file.txt": "default",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_deps",
		Target:    "default",
		TrimSpace: true,
		Files: map[string]string{
			"default.txt":     "default",
			"called_dep.txt":  "called_dep",
			"called_task.txt": "called_task",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_call_root_task",
		Target:    "included:call-root",
		TrimSpace: true,
		Files: map[string]string{
			"root_task.txt": "root task",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_optional",
		Target:    "default",
		TrimSpace: true,
		Files: map[string]string{
			"called_dep.txt": "called_dep",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	const dir = "testdata/includes_optional_implicit_false"
	wd, _ := os.Getwd()

	message := "task: No Taskfile found at \"%s/%s/TaskfileOptional.yml\""
	expected := fmt.Sprintf(message, wd, dir)

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
	)

	err := e.Setup()
	require.Error(t, err)
	assert.Equal(t, expected, err.Error())
}

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

	const dir = "testdata/includes_optional_explicit_false"
	wd, _ := os.Getwd()

	message := "task: No Taskfile found at \"%s/%s/TaskfileOptional.yml\""
	expected := fmt.Sprintf(message, wd, dir)

	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
	)

	err := e.Setup()
	require.Error(t, err)
	assert.Equal(t, expected, err.Error())
}

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

	tt := fileContentTest{
		Entrypoint: "testdata/includes_yaml/Custom.ext",
		Dir:        "testdata/includes_yaml",
		Target:     "default",
		TrimSpace:  true,
		Files: map[string]string{
			"main.txt":                         "main",
			"included_with_yaml_extension.txt": "included_with_yaml_extension",
			"included_with_custom_file.txt":    "included_with_custom_file",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	const dir = "testdata/includes_rel_path"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)

	require.NoError(t, e.Setup())

	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "common:pwd"}))
	assert.Contains(t, buff.String(), "testdata/includes_rel_path/common")

	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "included:common:pwd"}))
	assert.Contains(t, buff.String(), "testdata/includes_rel_path/common")
}

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

	const dir = "testdata/internal_task"
	tests := []struct {
		name           string
		task           string
		expectedErr    bool
		expectedOutput string
	}{
		{"included internal task via task", "task-1", false, "Hello, World!\n"},
		{"included internal task via dep", "task-2", false, "Hello, World!\n"},
		{"included internal direct", "included:task-3", true, "task: No tasks with description available. Try --list-all to list all tasks\n"},
	}

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

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			require.NoError(t, e.Setup())

			err := e.Run(t.Context(), &task.Call{Task: test.task})
			if test.expectedErr {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
			assert.Equal(t, test.expectedOutput, buff.String())
		})
	}
}

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

	const dir = "testdata/includes_flatten"
	tests := []struct {
		name           string
		taskfile       string
		task           string
		expectedErr    bool
		expectedOutput string
	}{
		{name: "included flatten", taskfile: "Taskfile.yml", task: "gen", expectedOutput: "gen from included\n"},
		{name: "included flatten with default", taskfile: "Taskfile.yml", task: "default", expectedOutput: "default from included flatten\n"},
		{name: "included flatten can call entrypoint tasks", taskfile: "Taskfile.yml", task: "from_entrypoint", expectedOutput: "from entrypoint\n"},
		{name: "included flatten with deps", taskfile: "Taskfile.yml", task: "with_deps", expectedOutput: "gen from included\nwith_deps from included\n"},
		{name: "included flatten nested", taskfile: "Taskfile.yml", task: "from_nested", expectedOutput: "from nested\n"},
		{name: "included flatten multiple same task", taskfile: "Taskfile.multiple.yml", task: "gen", expectedErr: true, expectedOutput: "task: Found multiple tasks (gen) included by \"included\"\""},
	}

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

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(dir),
				task.WithEntrypoint(dir+"/"+test.taskfile),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			err := e.Setup()
			if test.expectedErr {
				assert.EqualError(t, err, test.expectedOutput)
			} else {
				require.NoError(t, err)
				_ = e.Run(t.Context(), &task.Call{Task: test.task})
				assert.Equal(t, test.expectedOutput, buff.String())
			}
		})
	}
}

func TestIncludesInterpolation(t *testing.T) { // nolint:paralleltest // cannot run in parallel
	const dir = "testdata/includes_interpolation"
	tests := []struct {
		name           string
		task           string
		expectedErr    bool
		expectedOutput string
	}{
		{"include", "include", false, "include\n"},
		{"include_with_env_variable", "include-with-env-variable", false, "include_with_env_variable\n"},
		{"include_with_dir", "include-with-dir", false, "included\n"},
	}
	t.Setenv("MODULE", "included")

	for _, test := range tests { // nolint:paralleltest // cannot run in parallel
		t.Run(test.name, func(t *testing.T) {
			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(filepath.Join(dir, test.name)),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			require.NoError(t, e.Setup())

			err := e.Run(t.Context(), &task.Call{Task: test.task})
			if test.expectedErr {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
			assert.Equal(t, test.expectedOutput, buff.String())
		})
	}
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/includes_with_excludes"),
		task.WithSilent(true),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "included:bar"})
	require.NoError(t, err)
	assert.Equal(t, "bar\n", buff.String())
	buff.Reset()

	err = e.Run(t.Context(), &task.Call{Task: "included:foo"})
	require.Error(t, err)
	buff.Reset()

	err = e.Run(t.Context(), &task.Call{Task: "bar"})
	require.Error(t, err)
	buff.Reset()

	err = e.Run(t.Context(), &task.Call{Task: "foo"})
	require.NoError(t, err)
	assert.Equal(t, "foo\n", buff.String())
}

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

	const dir = "testdata/included_taskfile_var_merging"
	tests := []struct {
		name           string
		task           string
		expectedOutput string
	}{
		{"foo", "foo:pwd", "included_taskfile_var_merging/foo\n"},
		{"bar", "bar:pwd", "included_taskfile_var_merging/bar\n"},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			require.NoError(t, e.Setup())

			err := e.Run(t.Context(), &task.Call{Task: test.task})
			require.NoError(t, err)
			assert.Contains(t, buff.String(), test.expectedOutput)
		})
	}
}

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

	const dir = "testdata/internal_task"
	tests := []struct {
		name           string
		task           string
		expectedErr    bool
		expectedOutput string
	}{
		{"internal task via task", "task-1", false, "Hello, World!\n"},
		{"internal task via dep", "task-2", false, "Hello, World!\n"},
		{"internal direct", "task-3", true, ""},
	}

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

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			require.NoError(t, e.Setup())

			err := e.Run(t.Context(), &task.Call{Task: test.task})
			if test.expectedErr {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
			assert.Equal(t, test.expectedOutput, buff.String())
		})
	}
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_shadowed_default",
		Target:    "included",
		TrimSpace: true,
		Files: map[string]string{
			"file.txt": "shadowed",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/includes_unshadowed_default",
		Target:    "included",
		TrimSpace: true,
		Files: map[string]string{
			"file.txt": "included",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	fileNames := []string{
		"Taskfile.yml",
		"Taskfile.yaml",
		"Taskfile.dist.yml",
		"Taskfile.dist.yaml",
	}
	for _, fileName := range fileNames {
		t.Run(fileName, func(t *testing.T) {
			t.Parallel()

			tt := fileContentTest{
				Dir:       fmt.Sprintf("testdata/file_names/%s", fileName),
				Target:    "default",
				TrimSpace: true,
				Files: map[string]string{
					"output.txt": "hello",
				},
			}
			tt.Run(t)
		})
	}
}

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

	const dir = "testdata/summary"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSummary(true),
		task.WithSilent(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "task-with-summary"}, &task.Call{Task: "other-task-with-summary"}))

	data, err := os.ReadFile(filepathext.SmartJoin(dir, "task-with-summary.txt"))
	require.NoError(t, err)

	expectedOutput := string(data)
	if runtime.GOOS == "windows" {
		expectedOutput = strings.ReplaceAll(expectedOutput, "\r\n", "\n")
	}

	assert.Equal(t, expectedOutput, buff.String())
}

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

	const expected = "dir"
	const dir = "testdata/" + expected
	var out bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&out),
		task.WithStderr(&out),
	)

	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "whereami"}))

	// got should be the "dir" part of "testdata/dir"
	got := strings.TrimSuffix(filepath.Base(out.String()), "\n")
	assert.Equal(t, expected, got, "Mismatch in the working directory")
}

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

	const expected = "exists"
	const dir = "testdata/dir/explicit_exists"
	var out bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&out),
		task.WithStderr(&out),
	)

	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "whereami"}))

	got := strings.TrimSuffix(filepath.Base(out.String()), "\n")
	assert.Equal(t, expected, got, "Mismatch in the working directory")
}

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

	const expected = "createme"
	const dir = "testdata/dir/explicit_doesnt_exist/"
	const toBeCreated = dir + expected
	const target = "whereami"
	var out bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&out),
		task.WithStderr(&out),
	)

	// Ensure that the directory to be created doesn't actually exist.
	_ = os.RemoveAll(toBeCreated)
	if _, err := os.Stat(toBeCreated); err == nil {
		t.Errorf("Directory should not exist: %v", err)
	}
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: target}))

	got := strings.TrimSuffix(filepath.Base(out.String()), "\n")
	assert.Equal(t, expected, got, "Mismatch in the working directory")

	// Clean-up after ourselves only if no error.
	_ = os.RemoveAll(toBeCreated)
}

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

	const expected = "created"
	const dir = "testdata/dir/dynamic_var_on_created_dir/"
	const toBeCreated = dir + expected
	const target = "default"
	var out bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&out),
		task.WithStderr(&out),
	)

	// Ensure that the directory to be created doesn't actually exist.
	_ = os.RemoveAll(toBeCreated)
	if _, err := os.Stat(toBeCreated); err == nil {
		t.Errorf("Directory should not exist: %v", err)
	}
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: target}))

	got := strings.TrimSuffix(filepath.Base(out.String()), "\n")
	assert.Equal(t, expected, got, "Mismatch in the working directory")

	// Clean-up after ourselves only if no error.
	_ = os.RemoveAll(toBeCreated)
}

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

	tt := fileContentTest{
		Dir:       "testdata/dir/dynamic_var",
		Target:    "default",
		TrimSpace: false,
		Files: map[string]string{
			"subdirectory/from_root_taskfile.txt":          "subdirectory\n",
			"subdirectory/from_included_taskfile.txt":      "subdirectory\n",
			"subdirectory/from_included_taskfile_task.txt": "subdirectory\n",
			"subdirectory/from_interpolated_dir.txt":       "subdirectory\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	e := task.NewExecutor(
		task.WithDir("testdata/version/v1"),
		task.WithStdout(io.Discard),
		task.WithStderr(io.Discard),
		task.WithVersionCheck(true),
	)
	err := e.Setup()
	require.Error(t, err)
	assert.Regexp(t, regexp.MustCompile(`task: Invalid schema version in Taskfile \".*testdata\/version\/v1\/Taskfile\.yml\":\nSchema version \(1\.0\.0\) no longer supported\. Please use v3 or above`), err.Error())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/version/v2"),
		task.WithStdout(io.Discard),
		task.WithStderr(&buff),
		task.WithVersionCheck(true),
	)
	err := e.Setup()
	require.Error(t, err)
	assert.Regexp(t, regexp.MustCompile(`task: Invalid schema version in Taskfile \".*testdata\/version\/v2\/Taskfile\.yml\":\nSchema version \(2\.0\.0\) no longer supported\. Please use v3 or above`), err.Error())
}

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

	const dir = "testdata/short_task_notation"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))
	assert.Equal(t, "string-slice-1\nstring-slice-2\nstring\n", buff.String())
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv/default",
		Target:    "default",
		TrimSpace: false,
		Files: map[string]string{
			"include.txt": "INCLUDE1='from_include1' INCLUDE2='from_include2'\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/dotenv/error_included_envs"),
		task.WithSummary(true),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)

	err := e.Setup()
	require.Error(t, err)
	assert.Contains(t, err.Error(), "move the dotenv")
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv/missing_env",
		Target:    "default",
		TrimSpace: false,
		Files: map[string]string{
			"include.txt": "INCLUDE1='' INCLUDE2=''\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv/local_env_in_path",
		Target:    "default",
		TrimSpace: false,
		Files: map[string]string{
			"var.txt": "VAR='var_in_dot_env_1'\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv/local_var_in_path",
		Target:    "default",
		TrimSpace: false,
		Files: map[string]string{
			"var.txt": "VAR='var_in_dot_env_3'\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

func TestDotenvHasEnvVarInPath(t *testing.T) { // nolint:paralleltest // cannot run in parallel
	t.Setenv("ENV_VAR", "testing")

	tt := fileContentTest{
		Dir:       "testdata/dotenv/env_var_in_path",
		Target:    "default",
		TrimSpace: false,
		Files: map[string]string{
			"var.txt": "VAR='var_in_dot_env_2'\n",
		},
	}
	tt.Run(t)
}

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

	e := task.NewExecutor(
		task.WithDir("testdata/dotenv/parse_error"),
	)

	path, _ := filepath.Abs(filepath.Join(e.Dir, ".env-with-error"))
	expected := fmt.Sprintf("error reading env file %s:", path)

	err := e.Setup()
	require.ErrorContains(t, err, expected)
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv_task/default",
		Target:    "dotenv",
		TrimSpace: true,
		Files: map[string]string{
			"dotenv.txt": "foo",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv_task/default",
		Target:    "no-dotenv",
		TrimSpace: true,
		Files: map[string]string{
			"no-dotenv.txt": "global",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv_task/default",
		Target:    "dotenv-overridden-by-env",
		TrimSpace: true,
		Files: map[string]string{
			"dotenv-overridden-by-env.txt": "overridden",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:       "testdata/dotenv_task/default",
		Target:    "dotenv-with-var-name",
		TrimSpace: true,
		Files: map[string]string{
			"dotenv-with-var-name.txt": "foo",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	const dir = "testdata/exit_immediately"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(true),
	)
	require.NoError(t, e.Setup())

	require.Error(t, e.Run(t.Context(), &task.Call{Task: "default"}))
	assert.Contains(t, buff.String(), `"this_should_fail": executable file not found in $PATH`)
}

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

	tt := fileContentTest{
		Dir:    "testdata/run",
		Target: "generate-hash",
		Files: map[string]string{
			"hash.txt": "starting 1\n1\n2\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	tt := fileContentTest{
		Dir:    "testdata/run",
		Target: "deploy",
		Files: map[string]string{
			"wildcard.txt": "Deploy infra\nDeploy js\nDeploy go\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	const dir = "testdata/run_once_shared_deps"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithForceAll(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	rx := regexp.MustCompile(`task: \[service-[a,b]:library:build\] echo "build library"`)
	matches := rx.FindAllStringSubmatch(buff.String(), -1)
	assert.Len(t, matches, 1)
	assert.Contains(t, buff.String(), `task: [service-a:build] echo "build a"`)
	assert.Contains(t, buff.String(), `task: [service-b:build] echo "build b"`)
}

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

	const dir = "testdata/run_when_changed"

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithForceAll(true),
		task.WithSilent(true),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "start"}))
	expectedOutputOrder := strings.TrimSpace(`
login server=fubar user=fubar
login server=foo user=foo
login server=bar user=bar
`)
	assert.Contains(t, buff.String(), expectedOutputOrder)
}

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

	const dir = "testdata/deferred"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	expectedOutputOrder := strings.TrimSpace(`
task: [task-2] echo 'cmd ran'
cmd ran
task: [task-2] exit 1
task: [task-2] echo 'failing' && exit 2
failing
echo ran
task-1 ran successfully
task: [task-1] echo 'task-1 ran successfully'
task-1 ran successfully
`)
	require.Error(t, e.Run(t.Context(), &task.Call{Task: "task-2"}))
	assert.Contains(t, buff.String(), expectedOutputOrder)
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "parent"}))
	assert.Contains(t, buff.String(), "child task deferred value-from-parent")
}

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

	const dir = "testdata/exit_code"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "exit-zero"}))
	assert.Equal(t, "FOO=bar - DYNAMIC_FOO=bar - EXIT_CODE=", strings.TrimSpace(buff.String()))
}

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

	const dir = "testdata/exit_code"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	require.Error(t, e.Run(t.Context(), &task.Call{Task: "exit-one"}))
	assert.Equal(t, "FOO=bar - DYNAMIC_FOO=bar - EXIT_CODE=1", strings.TrimSpace(buff.String()))
}

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

	tests := []struct {
		name string
		dir  string
	}{
		{"nil cmd", "testdata/ignore_nil_elements/cmds"},
		{"nil dep", "testdata/ignore_nil_elements/deps"},
		{"nil include", "testdata/ignore_nil_elements/includes"},
		{"nil precondition", "testdata/ignore_nil_elements/preconditions"},
	}

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

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(test.dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			require.NoError(t, e.Setup())
			require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))
			assert.Equal(t, "string-slice-1\n", buff.String())
		})
	}
}

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

	const dir = "testdata/output_group"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	expectedOutputOrder := strings.TrimSpace(`
task: [hello] echo 'Hello!'
::group::hello
Hello!
::endgroup::
task: [bye] echo 'Bye!'
::group::bye
Bye!
::endgroup::
`)
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "bye"}))
	t.Log(buff.String())
	assert.Equal(t, strings.TrimSpace(buff.String()), expectedOutputOrder)
}

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

	const dir = "testdata/output_group_error_only"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "passing"}))
	t.Log(buff.String())
	assert.Empty(t, buff.String())
}

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

	const dir = "testdata/output_group_error_only"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	require.Error(t, e.Run(t.Context(), &task.Call{Task: "failing"}))
	t.Log(buff.String())
	assert.Contains(t, "failing-output", strings.TrimSpace(buff.String()))
	assert.NotContains(t, "passing", strings.TrimSpace(buff.String()))
}

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

	const dir = "testdata/include_with_vars"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	expectedOutputOrder := strings.TrimSpace(`
task: [included1:task1] echo "VAR_1 is included1-var1"
VAR_1 is included1-var1
task: [included1:task1] echo "VAR_2 is included-default-var2"
VAR_2 is included-default-var2
task: [included2:task1] echo "VAR_1 is included2-var1"
VAR_1 is included2-var1
task: [included2:task1] echo "VAR_2 is included-default-var2"
VAR_2 is included-default-var2
task: [included3:task1] echo "VAR_1 is included-default-var1"
VAR_1 is included-default-var1
task: [included3:task1] echo "VAR_2 is included-default-var2"
VAR_2 is included-default-var2
`)
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "task1"}))
	t.Log(buff.String())
	assert.Equal(t, strings.TrimSpace(buff.String()), expectedOutputOrder)
}

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

	const dir = "testdata/include_with_vars_inside_include"
	var buff bytes.Buffer
	e := task.Executor{
		Dir:    dir,
		Stdout: &buff,
		Stderr: &buff,
	}
	require.NoError(t, e.Setup())
}

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

	const dir = "testdata/include_with_vars_multi_level"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	expectedOutputOrder := strings.TrimSpace(`
task: [lib:greet] echo 'Hello world'
Hello world
task: [foo:lib:greet] echo 'Hello foo'
Hello foo
task: [bar:lib:greet] echo 'Hello bar'
Hello bar
`)
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))
	t.Log(buff.String())
	assert.Equal(t, expectedOutputOrder, strings.TrimSpace(buff.String()))
}

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

	const dir = "testdata/error_code"
	tests := []struct {
		name     string
		task     string
		expected int
	}{
		{
			name:     "direct task",
			task:     "direct",
			expected: 42,
		}, {
			name:     "indirect task",
			task:     "indirect",
			expected: 42,
		},
	}

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

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
			)
			require.NoError(t, e.Setup())

			err := e.Run(t.Context(), &task.Call{Task: test.task})
			require.Error(t, err)
			taskRunErr, ok := err.(*errors.TaskRunError)
			assert.True(t, ok, "cannot cast returned error to *task.TaskRunError")
			assert.Equal(t, test.expected, taskRunErr.TaskExitCode(), "unexpected exit code from task")
		})
	}
}

func TestEvaluateSymlinksInPaths(t *testing.T) { // nolint:paralleltest // cannot run in parallel
	const dir = "testdata/evaluate_symlinks_in_paths"
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(false),
	)
	tests := []struct {
		name     string
		task     string
		expected string
	}{
		{
			name:     "default (1)",
			task:     "default",
			expected: "task: [default] echo \"some job\"\nsome job",
		},
		{
			name:     "test-sym (1)",
			task:     "test-sym",
			expected: "task: [test-sym] echo \"shared file source changed\" > src/shared/b",
		},
		{
			name:     "default (2)",
			task:     "default",
			expected: "task: [default] echo \"some job\"\nsome job",
		},
		{
			name:     "default (3)",
			task:     "default",
			expected: `task: Task "default" is up to date`,
		},
		{
			name:     "reset",
			task:     "reset",
			expected: "task: [reset] echo \"shared file source\" > src/shared/b\ntask: [reset] echo \"file source\" > src/a",
		},
	}
	for _, test := range tests { // nolint:paralleltest // cannot run in parallel
		t.Run(test.name, func(t *testing.T) {
			require.NoError(t, e.Setup())
			err := e.Run(t.Context(), &task.Call{Task: test.task})
			require.NoError(t, err)
			assert.Equal(t, test.expected, strings.TrimSpace(buff.String()))
			buff.Reset()
		})
	}
	err := os.RemoveAll(dir + "/.task")
	require.NoError(t, err)
}

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

	tests := []struct {
		name     string
		dir      string
		expected string
	}{
		{
			name:     "walk from root directory",
			dir:      "testdata/taskfile_walk",
			expected: "foo\n",
		}, {
			name:     "walk from sub directory",
			dir:      "testdata/taskfile_walk/foo",
			expected: "foo\n",
		}, {
			name:     "walk from sub sub directory",
			dir:      "testdata/taskfile_walk/foo/bar",
			expected: "foo\n",
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir(test.dir),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
			)
			require.NoError(t, e.Setup())
			require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))
			assert.Equal(t, test.expected, buff.String())
		})
	}
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/user_working_dir"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	wd, err := os.Getwd()
	require.NoError(t, err)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "default"}))
	assert.Equal(t, fmt.Sprintf("%s\n", wd), buff.String())
}

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

	wd, err := os.Getwd()
	require.NoError(t, err)

	wd = filepathext.SmartJoin(wd, "testdata/user_working_dir_with_includes/somedir")

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/user_working_dir_with_includes"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	e.UserWorkingDir = wd

	require.NoError(t, err)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "included:echo"}))
	assert.Equal(t, fmt.Sprintf("%s\n", wd), buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/platforms"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build-" + runtime.GOOS}))
	assert.Equal(t, fmt.Sprintf("task: [build-%s] echo 'Running task on %s'\nRunning task on %s\n", runtime.GOOS, runtime.GOOS, runtime.GOOS), buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/shopts/global_level"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "pipefail"})
	require.NoError(t, err)
	assert.Equal(t, "pipefail\ton\n", buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/shopts/task_level"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "pipefail"})
	require.NoError(t, err)
	assert.Equal(t, "pipefail\ton\n", buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/shopts/command_level"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "pipefail"})
	require.NoError(t, err)
	assert.Equal(t, "pipefail\ton\n", buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/shopts/global_level"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "globstar"})
	require.NoError(t, err)
	assert.Equal(t, "globstar\ton\n", buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/shopts/task_level"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "globstar"})
	require.NoError(t, err)
	assert.Equal(t, "globstar\ton\n", buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/shopts/command_level"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "globstar"})
	require.NoError(t, err)
	assert.Equal(t, "globstar\ton\n", buff.String())
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/split_args"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(true),
	)
	require.NoError(t, e.Setup())

	vars := ast.NewVars()
	vars.Set("CLI_ARGS", ast.Var{Value: "foo bar 'foo bar baz'"})

	err := e.Run(t.Context(), &task.Call{Task: "default", Vars: vars})
	require.NoError(t, err)
	assert.Equal(t, "3\n", buff.String())
}

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

	tt := fileContentTest{
		Dir:    "testdata/single_cmd_dep",
		Target: "foo",
		Files: map[string]string{
			"foo.txt": "foo\n",
			"bar.txt": "bar\n",
		},
	}
	t.Run("", func(t *testing.T) {
		t.Parallel()
		tt.Run(t)
	})
}

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

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir("testdata/silent"),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithSilent(false),
	)
	require.NoError(t, e.Setup())

	// First verify that the silent flag is in place.
	fetchedTask, err := e.GetTask(&task.Call{Task: "task-test-silent-calls-chatty-silenced"})
	require.NoError(t, err, "Unable to look up task task-test-silent-calls-chatty-silenced")
	require.True(t, fetchedTask.Cmds[0].Silent, "The task task-test-silent-calls-chatty-silenced should have a silent call to chatty")

	// Then test the two basic cases where the task is silent or not.
	// A silenced task.
	err = e.Run(t.Context(), &task.Call{Task: "silent"})
	require.NoError(t, err)
	require.Empty(t, buff.String(), "siWhile running lent: Expected not see output, because the task is silent")

	buff.Reset()

	// A chatty (not silent) task.
	err = e.Run(t.Context(), &task.Call{Task: "chatty"})
	require.NoError(t, err)
	require.NotEmpty(t, buff.String(), "chWhile running atty: Expected to see output, because the task is not silent")

	buff.Reset()

	// Then test invoking the two task from other tasks.
	// A silenced task that calls a chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-silent-calls-chatty-non-silenced"})
	require.NoError(t, err)
	require.NotEmpty(t, buff.String(), "While running task-test-silent-calls-chatty-non-silenced: Expected to see output. The task is silenced, but the called task is not. Silence does not propagate to called tasks.")

	buff.Reset()

	// A silent task that does a silent call to a chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-silent-calls-chatty-silenced"})
	require.NoError(t, err)
	require.Empty(t, buff.String(), "While running task-test-silent-calls-chatty-silenced: Expected not to see output. The task calls chatty task, but the call is silenced.")

	buff.Reset()

	// A chatty task that does a call to a chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-chatty-calls-chatty-non-silenced"})
	require.NoError(t, err)
	require.NotEmpty(t, buff.String(), "While running task-test-chatty-calls-chatty-non-silenced: Expected to see output. Both caller and callee are chatty and not silenced.")

	buff.Reset()

	// A chatty task that does a silenced call to a chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-chatty-calls-chatty-silenced"})
	require.NoError(t, err)
	require.NotEmpty(t, buff.String(), "While running task-test-chatty-calls-chatty-silenced: Expected to see output. Call to a chatty task is silenced, but the parent task is not.")

	buff.Reset()

	// A chatty task with no cmd's of its own that does a silenced call to a chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-no-cmds-calls-chatty-silenced"})
	require.NoError(t, err)
	require.Empty(t, buff.String(), "While running task-test-no-cmds-calls-chatty-silenced: Expected not to see output. While the task itself is not silenced, it does not have any cmds and only does an invocation of a silenced task.")

	buff.Reset()

	// A chatty task that does a silenced invocation of a task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-chatty-calls-silenced-cmd"})
	require.NoError(t, err)
	require.Empty(t, buff.String(), "While running task-test-chatty-calls-silenced-cmd: Expected not to see output. While the task itself is not silenced, its call to the chatty task is silent.")

	buff.Reset()

	// Then test calls via dependencies.
	// A silent task that depends on a chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-is-silent-depends-on-chatty-non-silenced"})
	require.NoError(t, err)
	require.NotEmpty(t, buff.String(), "While running task-test-is-silent-depends-on-chatty-non-silenced: Expected to see output. The task is silent and depends on a chatty task. Dependencies does not inherit silence.")

	buff.Reset()

	// A silent task that depends on a silenced chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-is-silent-depends-on-chatty-silenced"})
	require.NoError(t, err)
	require.Empty(t, buff.String(), "While running task-test-is-silent-depends-on-chatty-silenced: Expected not to see output. The task is silent and has a silenced dependency on a chatty task.")

	buff.Reset()

	// A chatty task that, depends on a silenced chatty task.
	err = e.Run(t.Context(), &task.Call{Task: "task-test-is-chatty-depends-on-chatty-silenced"})
	require.NoError(t, err)
	require.Empty(t, buff.String(), "While running task-test-is-chatty-depends-on-chatty-silenced: Expected not to see output. The task is chatty but does not have commands and has a silenced dependency on a chatty task.")

	buff.Reset()
}

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

	tests := []struct {
		name     string
		force    bool
		forceAll bool
	}{
		{
			name:  "force",
			force: true,
		},
		{
			name:     "force-all",
			forceAll: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir("testdata/force"),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithForce(tt.force),
				task.WithForceAll(tt.forceAll),
			)
			require.NoError(t, e.Setup())
			require.NoError(t, e.Run(t.Context(), &task.Call{Task: "task-with-dep"}))
		})
	}
}

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

	tests := []struct {
		name           string
		call           string
		expectedOutput string
		wantErr        bool
	}{
		{
			name:           "basic wildcard",
			call:           "wildcard-foo",
			expectedOutput: "Hello foo\n",
		},
		{
			name:           "double wildcard",
			call:           "foo-wildcard-bar",
			expectedOutput: "Hello foo bar\n",
		},
		{
			name:           "store wildcard",
			call:           "start-foo",
			expectedOutput: "Starting foo\n",
		},
		{
			name:           "alias",
			call:           "s-foo",
			expectedOutput: "Starting foo\n",
		},
		{
			name:           "matches exactly",
			call:           "matches-exactly-*",
			expectedOutput: "I don't consume matches: []\n",
		},
		{
			name:    "no matches",
			call:    "no-match",
			wantErr: true,
		},
		{
			name:           "multiple matches",
			call:           "wildcard-foo-bar",
			expectedOutput: "Hello foo-bar\n",
		},
	}

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

			var buff bytes.Buffer
			e := task.NewExecutor(
				task.WithDir("testdata/wildcards"),
				task.WithStdout(&buff),
				task.WithStderr(&buff),
				task.WithSilent(true),
				task.WithForce(true),
			)
			require.NoError(t, e.Setup())
			if test.wantErr {
				require.Error(t, e.Run(t.Context(), &task.Call{Task: test.call}))
				return
			}
			require.NoError(t, e.Run(t.Context(), &task.Call{Task: test.call}))
			assert.Equal(t, test.expectedOutput, buff.String())
		})
	}
}

// enableExperimentForTest enables the experiment behind pointer e for the duration of test t and sub-tests,
// with the experiment being restored to its previous state when tests complete.
//
// Typically experiments are controlled via TASK_X_ env vars, but we cannot use those in tests
// because the experiment settings are parsed during experiments.init(), before any tests run.
func enableExperimentForTest(t *testing.T, e *experiments.Experiment, val int) {
	t.Helper()
	prev := *e
	*e = experiments.Experiment{
		Name:          prev.Name,
		AllowedValues: []int{val},
		Value:         val,
	}
	t.Cleanup(func() { *e = prev })
}

// copyTestdata copies a testdata fixture directory to a temp dir for tests
// that modify files. Returns the temp dir path.
func copyTestdata(t *testing.T, fixture string) string {
	t.Helper()
	src := filepath.Join("testdata", fixture)
	dst := t.TempDir()
	entries, err := os.ReadDir(src)
	require.NoError(t, err)
	for _, e := range entries {
		data, err := os.ReadFile(filepath.Join(src, e.Name()))
		require.NoError(t, err)
		require.NoError(t, os.WriteFile(filepath.Join(dst, e.Name()), data, 0o644))
	}
	return dst
}

func TestCacheRestoreHit(t *testing.T) {
	dir := copyTestdata(t, "cache")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// Run once — this populates the cache
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Verify cache was saved
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache dir should have one zip")

	// Delete generates and checksum — task is now out-of-date
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Run again — should restore from cache, not execute commands
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "build"}))

	// File should be restored from cache
	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	content, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	assert.Equal(t, "hello\n", string(content))

	// Output should mention cache restore, NOT command execution
	assert.Contains(t, buff.String(), "restored from cache")
}

func TestCacheDisabled(t *testing.T) {
	dir := copyTestdata(t, "cache_disabled")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Cache dir should NOT have been created
	_, err := os.Stat(cacheDir)
	assert.True(t, os.IsNotExist(err), "cache dir should not exist when disabled")
}

func TestCacheDisabledSkipsLocker(t *testing.T) {
	t.Parallel()
	// Regression: evalCacheLocker must not be called when cache is disabled.
	// The lock URL points to a nonexistent host — if the locker is evaluated,
	// the test will fail with a connection error.
	dir := copyTestdata(t, "cache_disabled_with_lock")

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Task should have run successfully without trying to connect to Redis
	output := filepath.Join(dir, "output.txt")
	_, err := os.Stat(output)
	assert.NoError(t, err, "output.txt should exist after successful run")
}

func TestCacheEnabledShellCondition(t *testing.T) {
	dir := copyTestdata(t, "cache_conditional")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Ensure ENABLE_CACHE is not set — condition should fail
	t.Setenv("ENABLE_CACHE", "")
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Cache should NOT have been used
	_, err := os.Stat(cacheDir)
	assert.True(t, os.IsNotExist(err), "cache should not be used when condition fails")
}

func TestCacheInheritFromTaskfile(t *testing.T) {
	dir := copyTestdata(t, "cache_inherit")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// Run once — should populate the cache using taskfile-level defaults
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Verify cache was saved
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache dir should have one zip")

	// Delete generates and checksum — task is now out-of-date
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Run again — should restore from cache
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "build"}))

	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	assert.Contains(t, buff.String(), "restored from cache")
}

func TestCacheInheritWithOverride(t *testing.T) {
	dir := copyTestdata(t, "cache_inherit_override")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// Run once — cache url is overridden to file:// even though taskfile default is redis://
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Verify cache was saved to the overridden file:// location
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache dir should have one zip from overridden url")

	// Delete generates and checksum
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Run again — should restore from the overridden file:// cache
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "build"}))

	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	assert.Contains(t, buff.String(), "restored from cache")
}

func TestChecksumIncludesRawCommands(t *testing.T) {
	// Regression: CHECKSUM must include raw command template strings so that
	// changing a command invalidates the fingerprint. The raw templates
	// (before variable resolution) are hashed, ensuring stability across
	// environments while still detecting command changes.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    sources:
      - source.txt
    cmds:
      - echo "{{.CHECKSUM}}" > output.txt
    generates:
      - output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// CHECKSUM should be non-empty in the generated output
	output, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	checksum := strings.TrimSpace(string(output))
	assert.NotEmpty(t, checksum, "CHECKSUM should be resolved in commands")
	assert.Regexp(t, `^[0-9a-f]+$`, checksum, "CHECKSUM should be a hex string")

	// Now change the command and verify CHECKSUM changes
	require.NoError(t, os.RemoveAll(tempDir))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    sources:
      - source.txt
    cmds:
      - echo "different-cmd {{.CHECKSUM}}" > output.txt
    generates:
      - output.txt
`), 0o644))

	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "build"}))

	output2, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	// Extract just the hex checksum from "different-cmd <hex>"
	parts := strings.Fields(strings.TrimSpace(string(output2)))
	require.True(t, len(parts) >= 2, "expected 'different-cmd <checksum>' in output")
	checksum2 := parts[len(parts)-1]

	assert.NotEqual(t, checksum, checksum2,
		"CHECKSUM should change when command template changes")
}

func TestFlockSerializesParallelTasks(t *testing.T) {
	// Verify that two concurrent invocations of the same fingerprinted task
	// are serialized by the filesystem lock.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	// The task writes start/end markers with a small sleep in between.
	// If locking works, the markers will be interleaved correctly.
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    sources:
      - source.txt
    generates:
      - output.txt
    cmds:
      - echo "start" >> log.txt
      - sleep 0.2
      - echo "end" >> log.txt
      - touch output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")

	run := func() error {
		var buff bytes.Buffer
		e := task.NewExecutor(
			task.WithDir(dir),
			task.WithStdout(&buff),
			task.WithStderr(&buff),
			task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
		)
		if err := e.Setup(); err != nil {
			return err
		}
		return e.Run(t.Context(), &task.Call{Task: "build"})
	}

	var wg sync.WaitGroup
	errs := make([]error, 2)
	for i := range errs {
		wg.Add(1)
		go func(idx int) {
			defer wg.Done()
			errs[idx] = run()
		}(i)
	}
	wg.Wait()

	// At least one should succeed (one runs, one may see up-to-date)
	require.NoError(t, errs[0])
	require.NoError(t, errs[1])

	// Log should never show interleaved "start start end end" —
	// locking ensures "start end start end" or the second sees up-to-date.
	logData, err := os.ReadFile(filepath.Join(dir, "log.txt"))
	require.NoError(t, err)
	lines := strings.Split(strings.TrimSpace(string(logData)), "\n")

	// If both ran, we should see start/end/start/end (not start/start/end/end)
	if len(lines) == 4 {
		assert.Equal(t, "start", lines[0])
		assert.Equal(t, "end", lines[1])
		assert.Equal(t, "start", lines[2])
		assert.Equal(t, "end", lines[3])
	}
	// If only one ran (other saw up-to-date), 2 lines is also fine
}

func TestStatusJSONFields(t *testing.T) {
	// Verify that StatusJSON returns all expected fields with correct types.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "src.txt"), []byte("data"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  compile:
    sources:
      - src.txt
    generates:
      - out.bin
    cmds:
      - cp src.txt out.bin
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "compile"}))

	buff.Reset()
	require.NoError(t, e.StatusJSON(&task.Call{Task: "compile"}))

	var result []map[string]any
	require.NoError(t, json.Unmarshal(buff.Bytes(), &result))
	require.Len(t, result, 1)

	st := result[0]
	assert.Equal(t, "compile", st["task"])
	assert.Equal(t, true, st["up_to_date"])
	assert.Equal(t, true, st["sources_up_to_date"])
	assert.Equal(t, true, st["generates_up_to_date"])
	assert.NotEmpty(t, st["checksum_file"])
	assert.NotEmpty(t, st["sources_hash"])
	assert.NotEmpty(t, st["generates_hash"])

	// source_files and source_data should be arrays
	srcFiles, ok := st["source_files"].([]any)
	assert.True(t, ok, "source_files should be an array")
	assert.NotEmpty(t, srcFiles)

	srcData, ok := st["source_data"].([]any)
	assert.True(t, ok, "source_data should be an array")
	assert.NotEmpty(t, srcData)

	genFiles, ok := st["generate_files"].([]any)
	assert.True(t, ok, "generate_files should be an array")
	assert.NotEmpty(t, genFiles)
}

func TestCacheEnabledConditionTrue(t *testing.T) {
	// When the cache condition evaluates to true, the cache should be used.
	dir := copyTestdata(t, "cache_conditional")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)
	t.Setenv("ENABLE_CACHE", "1")

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Cache dir should have been created
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache should be used when condition is true")

	// Delete generates and checksum to force cache restore
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "build"}))

	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	assert.Contains(t, buff.String(), "restored from cache")
}

func TestCacheURLSafeTaskName(t *testing.T) {
	// Verify that {{urlsafe .TASK}} in cache URLs correctly encodes
	// special characters like colons from namespaced task names.
	dir := copyTestdata(t, "cache_inherit")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Verify cache was saved — the URL contains {{urlsafe .TASK}}
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache should have been saved with urlsafe task name")

	// Verify the filename doesn't contain raw special chars
	for _, entry := range entries {
		assert.NotContains(t, entry.Name(), ":", "cache filename should be URL-safe")
	}
}

func TestCacheChecksumConsistency(t *testing.T) {
	dir := copyTestdata(t, "cache_checksum_consistency")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)
	t.Setenv("GREETING", "hello")
	tempDir := filepath.Join(dir, ".task")

	run := func() string {
		var buff bytes.Buffer
		e := task.NewExecutor(
			task.WithDir(dir),
			task.WithStdout(&buff),
			task.WithStderr(&buff),
			task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
		)
		require.NoError(t, e.Setup())
		require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
		return buff.String()
	}

	readChecksum := func() string {
		content, err := os.ReadFile(filepath.Join(dir, "output.txt"))
		require.NoError(t, err)
		// output is "CHECKSUM GREETING", extract just the checksum
		fields := strings.Fields(strings.TrimSpace(string(content)))
		require.NotEmpty(t, fields)
		return fields[0]
	}

	cacheZips := func() []string {
		entries, err := os.ReadDir(cacheDir)
		require.NoError(t, err)
		var names []string
		for _, e := range entries {
			names = append(names, e.Name())
		}
		return names
	}

	// First run — populates cache and output.txt
	run()
	origChecksum := readChecksum()
	assert.NotEmpty(t, origChecksum)

	// Cache zip should match the checksum from the command
	zips := cacheZips()
	require.Len(t, zips, 1)
	assert.Equal(t, "build-"+origChecksum+".zip", zips[0],
		"cache zip filename should contain the same CHECKSUM used in the command")

	// Second run — task should be up-to-date (cached)
	out := run()
	assert.Contains(t, out, "up to date")

	// Remove output.txt, run again — should restore from cache with same checksum
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))
	out = run()
	assert.Contains(t, out, "restored from cache")
	assert.Equal(t, origChecksum, readChecksum(),
		"restored output should contain the same CHECKSUM")

	// Change the command in the Taskfile — checksum should differ
	taskfilePath := filepath.Join(dir, "Taskfile.yml")
	taskfileBytes, err := os.ReadFile(taskfilePath)
	require.NoError(t, err)
	modified := strings.Replace(string(taskfileBytes),
		`echo "{{.CHECKSUM}} {{.GREETING}}" > output.txt`,
		`printf "{{.CHECKSUM}} {{.GREETING}}" > output.txt`,
		1)
	require.NoError(t, os.WriteFile(taskfilePath, []byte(modified), 0o644))
	require.NoError(t, os.RemoveAll(tempDir))
	run()
	cmdChangedChecksum := readChecksum()
	assert.NotEqual(t, origChecksum, cmdChangedChecksum,
		"changing a command should produce a different CHECKSUM")

	// Restore original Taskfile, change input.txt — checksum should differ
	require.NoError(t, os.WriteFile(taskfilePath, taskfileBytes, 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("changed\n"), 0o644))
	require.NoError(t, os.RemoveAll(tempDir))
	run()
	inputChangedChecksum := readChecksum()
	assert.NotEqual(t, origChecksum, inputChangedChecksum,
		"changing input should produce a different CHECKSUM")
	assert.NotEqual(t, cmdChangedChecksum, inputChangedChecksum,
		"cmd change and input change should produce different CHECKSUMs")

	// Restore original input — checksum should match the original
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello\n"), 0o644))
	require.NoError(t, os.RemoveAll(tempDir))
	run()
	assert.Equal(t, origChecksum, readChecksum(),
		"restoring original values should produce the original CHECKSUM")

	// Changing a variable value should NOT change the checksum —
	// CHECKSUM is computed from raw command templates, not resolved commands.
	// But the resolved output should differ, proving the variable was resolved.
	t.Setenv("GREETING", "world")
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))
	require.NoError(t, os.RemoveAll(cacheDir))
	run()
	assert.Equal(t, origChecksum, readChecksum(),
		"changing a variable value should not change CHECKSUM (raw commands are checksummed)")
	newOutput, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	assert.Contains(t, string(newOutput), "world",
		"resolved output should reflect the new variable value")
	assert.NotContains(t, string(newOutput), "hello",
		"resolved output should no longer contain the old variable value")
}

func TestCacheMetaSourcesMatchesChecksum(t *testing.T) {
	// The sources hash stored in the zip comment must match the CHECKSUM
	// template variable (which is embedded in the cache zip filename).
	dir := copyTestdata(t, "cache_checksum_consistency")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)
	t.Setenv("GREETING", "hello")
	tempDir := filepath.Join(dir, ".task")

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))

	// Find the cache zip
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	require.Len(t, entries, 1)
	zipName := entries[0].Name()

	// Extract CHECKSUM from filename: "build-<CHECKSUM>.zip"
	checksum := strings.TrimPrefix(zipName, "build-")
	checksum = strings.TrimSuffix(checksum, ".zip")
	require.NotEmpty(t, checksum)

	// Read zip comment
	zipPath := filepath.Join(cacheDir, zipName)
	zf, err := os.Open(zipPath)
	require.NoError(t, err)
	defer zf.Close()
	stat, err := zf.Stat()
	require.NoError(t, err)
	zr, err := zip.NewReader(zf, stat.Size())
	require.NoError(t, err)

	// Parse sources hash from comment
	var sourcesHash string
	for _, line := range strings.Split(zr.Comment, "\n") {
		if v, ok := strings.CutPrefix(line, "sources:"); ok {
			sourcesHash = v
		}
	}

	assert.Equal(t, checksum, sourcesHash,
		"sources hash in zip comment must match CHECKSUM in filename")
}

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

	// When cache is enabled and generates reference files outside the
	// project root, task compilation must fail early rather than producing
	// a zip with path-traversal entries.
	dir := t.TempDir()
	outsideDir := t.TempDir()
	cacheDir := t.TempDir()

	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "escaped.txt"), []byte("escaped"), 0o644))

	// Generates points to a directory outside the project root, cache enabled
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(fmt.Sprintf(`version: '3'
tasks:
  build:
    sources:
      - input.txt
    generates:
      - "%s/escaped.txt"
    cache:
      url: "file://%s/build-{{.CHECKSUM}}.zip"
    cmds:
      - echo ok
`, outsideDir, cacheDir)), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Run should fail at compilation because generates escape the project root
	err := e.Run(t.Context(), &task.Call{Task: "build"})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "outside project root")
}

func TestCacheDepGenerates(t *testing.T) {
	// A wrapper task with cache enabled but no generates of its own should
	// collect generates from its deps and include them in the cache archive.
	dir := copyTestdata(t, "cache_dep_generates")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// Run once — should populate the cache with dep generates
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.FileExists(t, filepath.Join(dir, "output-a.txt"))
	assert.FileExists(t, filepath.Join(dir, "output-b.txt"))

	// Verify cache was saved
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache dir should have one zip from the wrapper task")

	// Delete generates and checksum — task is now out-of-date
	require.NoError(t, os.Remove(filepath.Join(dir, "output-a.txt")))
	require.NoError(t, os.Remove(filepath.Join(dir, "output-b.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Run again — should restore from cache
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "wrapper"}))

	// Both dep generates should be restored from cache
	assert.FileExists(t, filepath.Join(dir, "output-a.txt"))
	assert.FileExists(t, filepath.Join(dir, "output-b.txt"))
	contentA, err := os.ReadFile(filepath.Join(dir, "output-a.txt"))
	require.NoError(t, err)
	assert.Equal(t, "hello\n", string(contentA))
	contentB, err := os.ReadFile(filepath.Join(dir, "output-b.txt"))
	require.NoError(t, err)
	assert.Equal(t, "hello\n", string(contentB))
	assert.Contains(t, buff.String(), "restored from cache")
}

func TestCacheDepGeneratesNested(t *testing.T) {
	// A wrapper task whose deps themselves have no generates but delegate
	// to further sub-tasks via cmds should still collect the leaf generates.
	dir := copyTestdata(t, "cache_dep_generates_nested")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// Run once — populates cache
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "top"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Verify cache was saved
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache dir should have one zip")

	// Delete generates and checksum
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Run again — should restore from cache
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "top"}))

	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	content, err := os.ReadFile(filepath.Join(dir, "output.txt"))
	require.NoError(t, err)
	assert.Equal(t, "hello\n", string(content))
	assert.Contains(t, buff.String(), "restored from cache")
}

func TestCacheHitSkipsDeps(t *testing.T) {
	// When a wrapper task with "from: deps" gets a cache hit, deps should
	// NOT execute at all. This verifies the execution order: fingerprint
	// and cache checks run BEFORE deps.
	dir := copyTestdata(t, "cache_skips_deps")
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// First run — populates cache, dep runs
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	assert.Contains(t, buff.String(), "EXPENSIVE-BUILD-RAN", "dep should run on first execution")

	// Verify cache was saved
	entries, err := os.ReadDir(cacheDir)
	require.NoError(t, err)
	assert.Len(t, entries, 1, "cache dir should have one zip")

	// Delete generates and checksum — forces cache restore path
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	// Second run — should restore from cache, deps must NOT run
	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "wrapper"}))

	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	assert.Contains(t, buff.String(), "restored from cache")
	assert.NotContains(t, buff.String(), "EXPENSIVE-BUILD-RAN",
		"deps should NOT run when cache provides the result")
}

func TestUpToDateSkipsDeps(t *testing.T) {
	t.Parallel()
	// When a task with deps is already up-to-date (fingerprint match),
	// deps should NOT execute. The fingerprint check runs before deps.
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  parent:
    sources:
      - from: deps
    generates:
      - from: deps
    deps:
      - child

  child:
    sources:
      - input.txt
    generates:
      - output.txt
    cmds:
      - echo "CHILD-RAN" >&2
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// First run — child runs
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "parent"}))
	assert.Contains(t, buff.String(), "CHILD-RAN")

	// Second run — parent is up-to-date, child should NOT run
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "parent"}))
	assert.Contains(t, buff.String(), "up to date")
	assert.NotContains(t, buff.String(), "CHILD-RAN",
		"deps should NOT run when parent is already up to date")
}

func TestCachedDepSkipsExpensiveWork(t *testing.T) {
	// Mimics a pattern where a wrapper task (e.g. doc:manuals)
	// depends on a build task (e.g. doc:manuals:build) that does
	// the actual expensive work. Previously we had to call the build task
	// directly first to prime the cache, then call the wrapper:
	//
	//   task -C 1 doc:manuals:build   # prime cache
	//   task -C 1 doc:manuals         # wrapper
	//
	// With the wrapper alone the call to doc:manuals would check its fingerprint, see it's out of date,
	// call its dep doc:manuals:build, which would restore from cache and skip the expensive build.

	dir := t.TempDir()
	cacheDir := filepath.Join(t.TempDir(), "cache")
	t.Setenv("CACHE_DIR", cacheDir)
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("hello\n"), 0o644))

	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
vars:
  CACHE_DIR:
    sh: echo "$CACHE_DIR"

tasks:
  # Wrapper — like doc:bastion:manuals. No cmds, no cache, just deps.
  manuals:
    deps:
      - manuals:build

  # Build — like doc:bastion:manuals:build. Does expensive work, has cache.
  manuals:build:
    sources:
      - input.txt
    generates:
      - output.txt
    cache:
      url: 'file://{{.CACHE_DIR}}/build-{{.CHECKSUM}}.zip'
    cmds:
      - echo "BUILD-RAN" >&2
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer

	// === Job A: first CI job builds and populates cache ===
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "manuals"}))
	assert.Contains(t, buff.String(), "BUILD-RAN", "build dep should run on first invocation")
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// === Job B: different CI job, no local state, only the shared cache ===
	require.NoError(t, os.Remove(filepath.Join(dir, "output.txt")))
	require.NoError(t, os.RemoveAll(tempDir))

	buff.Reset()
	e2 := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e2.Setup())

	// Just call the wrapper — no need to call manuals:build first
	require.NoError(t, e2.Run(t.Context(), &task.Call{Task: "manuals"}))

	assert.FileExists(t, filepath.Join(dir, "output.txt"))
	assert.Contains(t, buff.String(), "restored from cache",
		"wrapper should restore from cache without calling build dep first")
	assert.NotContains(t, buff.String(), "BUILD-RAN",
		"build dep should NOT run when wrapper gets a cache hit")
}

func TestFromSourcesDeps(t *testing.T) {
	t.Parallel()
	// "from: deps" in sources should collect sources from direct deps.
	// When two deps share the same source, it should be deduplicated.
	dir := copyTestdata(t, "from_sources_deps")

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Run once — should execute
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.FileExists(t, filepath.Join(dir, "output-a.txt"))
	assert.FileExists(t, filepath.Join(dir, "output-b.txt"))

	// Second run — should be up to date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.Contains(t, buff.String(), "up to date")

	// Modify the shared source — wrapper should re-execute
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("changed\n"), 0o644))
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.NotContains(t, buff.String(), `Task "wrapper" is up to date`)

	// Verify status output has deduplicated sources
	buff.Reset()
	require.NoError(t, e.Status(&task.Call{Task: "wrapper"}))
	out := buff.String()
	// input.txt should appear exactly once as a srcrule
	assert.Equal(t, 1, strings.Count(out, "srcrule:input.txt"), "input.txt should be deduplicated in sources, got:\n%s", out)
}

func TestFromMixed(t *testing.T) {
	t.Parallel()
	// A task with both literal globs and "from: deps" in sources/generates.
	dir := copyTestdata(t, "from_mixed")

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Run — should execute both leaf and wrapper
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.FileExists(t, filepath.Join(dir, "leaf-out.txt"))
	assert.FileExists(t, filepath.Join(dir, "result.txt"))

	// Second run — up to date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.Contains(t, buff.String(), "up to date")

	// Verify status shows both own and inherited sources/generates
	buff.Reset()
	require.NoError(t, e.Status(&task.Call{Task: "wrapper"}))
	out := buff.String()
	assert.Contains(t, out, "srcrule:config.txt")
	assert.Contains(t, out, "srcrule:input.txt")
	assert.Contains(t, out, "genrule:result.txt")
	assert.Contains(t, out, "genrule:leaf-out.txt")

	// Change inherited source — wrapper should re-run
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("new\n"), 0o644))
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.NotContains(t, buff.String(), "up to date")
}

func TestFromDepsChildDifferentDir(t *testing.T) {
	// Regression: when a "from: deps" child task has a different dir than
	// the parent, its relative globs must be resolved against the child's
	// dir. Otherwise source files never match, the checksum is computed
	// from static metadata only, and the wrapper is incorrectly reported
	// as up-to-date after the first run even when sources have changed.
	t.Parallel()

	dir := t.TempDir()
	subDir := filepath.Join(dir, "sub")
	require.NoError(t, os.MkdirAll(subDir, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(subDir, "input.txt"), []byte("data\n"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  wrapper:
    sources:
      - from: deps
    generates:
      - from: deps
    deps:
      - leaf
    cmds:
      - true

  leaf:
    dir: sub
    sources:
      - input.txt
    generates:
      - output.txt
    cmds:
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// First run — produces output in the child's dir
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.FileExists(t, filepath.Join(subDir, "output.txt"))

	// Second run — up to date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.Contains(t, buff.String(), "up to date")

	// Change the child's source — wrapper must detect it and re-run.
	// Before the fix, the child's "input.txt" glob was resolved against
	// the parent's dir, matched nothing, and the wrapper stayed "up to date".
	require.NoError(t, os.WriteFile(filepath.Join(subDir, "input.txt"), []byte("changed\n"), 0o644))
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.NotContains(t, buff.String(), "up to date", "wrapper should detect source change in child's dir")
}

func TestFromSourcesCmds(t *testing.T) {
	// "from: cmds" in sources/generates should collect from cmd task-calls.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("data\n"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  wrapper:
    sources:
      - from: cmds
    generates:
      - from: cmds
    cmds:
      - task: worker

  worker:
    sources:
      - input.txt
    generates:
      - output.txt
    cmds:
      - cp input.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// Run
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Second run — up to date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.Contains(t, buff.String(), "up to date")

	// Modify source — should re-run
	require.NoError(t, os.WriteFile(filepath.Join(dir, "input.txt"), []byte("changed\n"), 0o644))
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "wrapper"}))
	assert.NotContains(t, buff.String(), "up to date")
}

func TestFromInvalidValue(t *testing.T) {
	// An unsupported from: value should produce an error.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  bad:
    sources:
      - from: invalid
    cmds:
      - echo hello
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	err := e.Run(t.Context(), &task.Call{Task: "bad"})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unsupported from:")
}

func TestStatusOutputGrouping(t *testing.T) {
	// Verify that --status output groups genrule: entries under generates,
	// not under sources.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  build:
    cmds:
      - cp source.txt generated.txt
    sources:
      - source.txt
    generates:
      - generated.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	require.NoError(t, e.Status(&task.Call{Task: "build"}))
	out := buff.String()

	// genrule: should appear after "generates:", not after "sources:"
	srcIdx := strings.Index(out, "sources:")
	genIdx := strings.Index(out, "generates:")
	genRuleIdx := strings.Index(out, "genrule:")
	require.Greater(t, srcIdx, -1, "sources: not found in output:\n%s", out)
	require.Greater(t, genIdx, -1, "generates: not found in output:\n%s", out)
	require.Greater(t, genRuleIdx, -1, "genrule: not found in output:\n%s", out)
	assert.Greater(t, genRuleIdx, genIdx, "genrule: should appear after generates: header, got:\n%s", out)

	// srcrule: should appear before generates:
	srcRuleIdx := strings.Index(out, "srcrule:")
	require.Greater(t, srcRuleIdx, -1, "srcrule: not found in output:\n%s", out)
	assert.Less(t, srcRuleIdx, genIdx, "srcrule: should appear before generates: header, got:\n%s", out)
}

func TestSetupSourcesNotMergedIntoFingerprint(t *testing.T) {
	// Setup task sources should NOT be merged into the parent's fingerprint.
	// Changing a setup task's source file should not cause the parent to
	// re-execute if the parent's own sources are unchanged.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "setup-src.txt"), []byte("v1"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "main-src.txt"), []byte("main"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  prepare:
    sources:
      - setup-src.txt
    cmds:
      - 'true'

  build:
    setup:
      - prepare
    sources:
      - main-src.txt
    generates:
      - output.txt
    cmds:
      - cp main-src.txt output.txt
`), 0o644))

	tempDir := filepath.Join(dir, ".task")
	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: tempDir}),
	)
	require.NoError(t, e.Setup())

	// First run: task executes
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.FileExists(t, filepath.Join(dir, "output.txt"))

	// Second run: task should be up-to-date
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), "up to date")

	// Change the setup task's source file
	require.NoError(t, os.WriteFile(filepath.Join(dir, "setup-src.txt"), []byte("v2"), 0o644))

	// Third run: parent should still be up-to-date because its own sources
	// are unchanged — setup sources are not part of the parent's fingerprint.
	buff.Reset()
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "build"}))
	assert.Contains(t, buff.String(), `Task "build" is up to date`,
		"parent should remain up-to-date when only setup source changes")
}

func TestSetupRunOnce(t *testing.T) {
	// A setup task with "run: once" should only execute once even when
	// multiple tasks reference it as a setup dependency.
	t.Parallel()

	dir := t.TempDir()
	logFile := filepath.Join(dir, "setup.log")
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(fmt.Sprintf(`version: '3'
tasks:
  prepare:
    run: once
    cmds:
      - echo ran >> %s

  build-a:
    setup:
      - prepare
    cmds:
      - 'true'

  build-b:
    setup:
      - prepare
    cmds:
      - 'true'

  all:
    deps:
      - build-a
      - build-b
`, logFile)), 0o644))

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: filepath.Join(dir, ".task")}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "all"}))

	log, err := os.ReadFile(logFile)
	require.NoError(t, err)
	lines := strings.Split(strings.TrimSpace(string(log)), "\n")
	assert.Equal(t, 1, len(lines), "setup with run:once should have run exactly once, got: %s", string(log))
}

func TestSetupRunOnceNested(t *testing.T) {
	// A setup task with "run: once" should only execute once even when
	// referenced from nested task calls at different depths.
	t.Parallel()

	dir := t.TempDir()
	logFile := filepath.Join(dir, "setup.log")
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(fmt.Sprintf(`version: '3'
tasks:
  prepare:
    run: once
    cmds:
      - echo ran >> %s

  inner-a:
    setup:
      - prepare
    cmds:
      - 'true'

  inner-b:
    setup:
      - prepare
    cmds:
      - 'true'

  outer-a:
    setup:
      - prepare
    cmds:
      - task: inner-a

  outer-b:
    deps:
      - inner-b
    cmds:
      - 'true'

  all:
    deps:
      - outer-a
      - outer-b
`, logFile)), 0o644))

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithTempDir(task.TempDir{Fingerprint: filepath.Join(dir, ".task")}),
	)
	require.NoError(t, e.Setup())
	require.NoError(t, e.Run(t.Context(), &task.Call{Task: "all"}))

	log, err := os.ReadFile(logFile)
	require.NoError(t, err)
	lines := strings.Split(strings.TrimSpace(string(log)), "\n")
	assert.Equal(t, 1, len(lines), "nested setup with run:once should have run exactly once, got: %s", string(log))
}

func TestSetupWithConcurrencyLimit(t *testing.T) {
	// Regression test: with -C 1, a task that has a setup task would
	// deadlock because runSetup calls RunTask which tries to acquire
	// the concurrency slot already held by the parent task.
	t.Parallel()

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "source.txt"), []byte("hello"), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(`version: '3'
tasks:
  prepare:
    cmds:
      - 'true'

  build:
    setup:
      - prepare
    sources:
      - source.txt
    generates:
      - output.txt
    cmds:
      - cp source.txt output.txt

  all:
    deps:
      - build
`), 0o644))

	var buff bytes.Buffer
	e := task.NewExecutor(
		task.WithDir(dir),
		task.WithStdout(&buff),
		task.WithStderr(&buff),
		task.WithConcurrency(1),
		task.WithTempDir(task.TempDir{Fingerprint: filepath.Join(dir, ".task")}),
	)
	require.NoError(t, e.Setup())

	done := make(chan error, 1)
	go func() {
		done <- e.Run(t.Context(), &task.Call{Task: "all"})
	}()

	select {
	case err := <-done:
		require.NoError(t, err)
	case <-time.After(10 * time.Second):
		t.Fatal("deadlock: setup task blocked on concurrency semaphore with -C 1")
	}
}