task/executor_test.go

3313 lines
81 KiB
Go

package task_test
import (
"bytes"
"cmp"
"context"
"fmt"
"io/fs"
rand "math/rand/v2"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"regexp"
"runtime"
"strings"
"testing"
"time"
"github.com/Masterminds/semver/v3"
"github.com/sebdah/goldie/v2"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/go-task/task/v3"
"github.com/go-task/task/v3/errors"
"github.com/go-task/task/v3/experiments"
"github.com/go-task/task/v3/internal/filepathext"
"github.com/go-task/task/v3/taskfile/ast"
)
type (
// A ExecutorTestOption is a function that configures an [ExecutorTest].
ExecutorTestOption interface {
applyToExecutorTest(*ExecutorTest)
}
// A ExecutorTest is a test wrapper around a [task.Executor] to make it easy
// to write tests for tasks. See [NewExecutorTest] for information on
// creating and running ExecutorTests. These tests use fixture files to
// assert whether the result of a task is correct. If Task's behavior has
// been changed, the fixture files can be updated by running `task
// gen:fixtures`.
ExecutorTest struct {
TaskTest
task string
tasks []string
vars map[string]any
input string
executorOpts []task.ExecutorOption
wantSetupError bool
wantRunError bool
wantStatusError bool
noRun bool
assertFns []func(t *testing.T, r *ExecutorTestResult)
}
// An ExecutorTestResult carries the outcome of an [ExecutorTest] run. It is
// passed to any assertion functions registered with [WithAssert], for
// checks that a golden fixture can't express, such as an error's concrete
// type, timing bounds, or the [task.Executor]'s internal state.
ExecutorTestResult struct {
Executor *task.Executor
Output string
Err error
Duration time.Duration
}
)
// NewExecutorTest sets up a new [task.Executor] with the given options and runs
// a task with the given [ExecutorTestOption]s. The output of the task is
// written to a set of fixture files depending on the configuration of the test.
func NewExecutorTest(t *testing.T, opts ...ExecutorTestOption) {
t.Helper()
tt := &ExecutorTest{
task: "default",
vars: map[string]any{},
TaskTest: TaskTest{
experiments: map[*experiments.Experiment]int{},
fixtureTemplateData: map[string]any{},
},
}
// Apply the functional options
for _, opt := range opts {
opt.applyToExecutorTest(tt)
}
// Enable any experiments that have been set
for x, v := range tt.experiments {
prev := *x
*x = experiments.Experiment{
Name: prev.Name,
AllowedValues: []int{v},
Value: v,
}
t.Cleanup(func() {
*x = prev
})
}
tt.run(t)
}
// Helpers
// writeFixtureErrRun is a wrapper for writing the output of an error during the
// run phase of the task to a fixture file.
func (tt *ExecutorTest) writeFixtureErrRun(
t *testing.T,
g *goldie.Goldie,
err error,
) {
t.Helper()
tt.writeFixture(t, g, "err-run", []byte(err.Error()))
}
// writeFixtureStatus is a wrapper for writing the output of an error when
// making an additional call to [task.Executor.Status] to a fixture file.
func (tt *ExecutorTest) writeFixtureStatus(
t *testing.T,
g *goldie.Goldie,
status string,
) {
t.Helper()
tt.writeFixture(t, g, "err-status", []byte(status))
}
// run is the main function for running the test. It sets up the task executor,
// runs the task, and writes the output to a fixture file.
func (tt *ExecutorTest) run(t *testing.T) {
t.Helper()
f := func(t *testing.T) {
t.Helper()
var buffer SyncBuffer
opts := append(
tt.executorOpts,
task.WithStdout(&buffer),
task.WithStderr(&buffer),
)
// If the test has input, create a reader for it and add it to the
// executor options
if tt.input != "" {
var reader bytes.Buffer
reader.WriteString(tt.input)
opts = append(opts, task.WithStdin(&reader))
}
// Set up the task executor
e := task.NewExecutor(opts...)
// Create a golden fixture file for the output
g := goldie.New(t,
goldie.WithFixtureDir(filepath.Join(e.Dir, "testdata")),
goldie.WithEqualFn(NormalizedEqual),
)
// runAsserts runs any functions registered with WithAssert against the
// current outcome of the test.
runAsserts := func(result *ExecutorTestResult) {
t.Helper()
for _, fn := range tt.assertFns {
fn(t, result)
}
}
// Call setup and check for errors
if err := e.Setup(); tt.wantSetupError {
require.Error(t, err)
runAsserts(&ExecutorTestResult{Executor: e, Err: err})
tt.writeFixtureErrSetup(t, g, err)
tt.writeFixtureBuffer(t, g, buffer.buf)
return
} else {
require.NoError(t, err)
}
// If the test doesn't want to run a task, stop here. There's no
// output, so no fixture is written.
if tt.noRun {
runAsserts(&ExecutorTestResult{Executor: e})
return
}
// Create the task call(s)
vars := ast.NewVars()
for key, value := range tt.vars {
vars.Set(key, ast.Var{Value: value})
}
taskNames := tt.tasks
if len(taskNames) == 0 {
taskNames = []string{tt.task}
}
calls := make([]*task.Call, 0, len(taskNames))
for _, name := range taskNames {
calls = append(calls, &task.Call{Task: name, Vars: vars})
}
// Run the task and check for errors
ctx := t.Context()
start := time.Now()
err := e.Run(ctx, calls...)
duration := time.Since(start)
if tt.wantRunError {
require.Error(t, err)
runAsserts(&ExecutorTestResult{Executor: e, Output: buffer.buf.String(), Err: err, Duration: duration})
tt.writeFixtureErrRun(t, g, err)
tt.writeFixtureBuffer(t, g, buffer.buf)
return
} else {
require.NoError(t, err)
}
runAsserts(&ExecutorTestResult{Executor: e, Output: buffer.buf.String(), Duration: duration})
// If the status flag is set, run the status check
if tt.wantStatusError {
if err := e.Status(ctx, calls[0]); err != nil {
tt.writeFixtureStatus(t, g, err.Error())
}
}
tt.writeFixtureBuffer(t, g, buffer.buf)
}
// Run the test (with a name if it has one)
if tt.name != "" {
t.Run(tt.name, f)
} else {
f(t)
}
}
func TestEmptyTask(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/empty_task"),
),
)
}
func TestEmptyTaskfile(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/empty_taskfile"),
),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestEnv(t *testing.T) {
t.Setenv("QUX", "from_os")
NewExecutorTest(t,
WithName("env precedence disabled"),
WithExecutorOptions(
task.WithDir("testdata/env"),
task.WithSilent(true),
),
)
NewExecutorTest(t,
WithName("env precedence enabled"),
WithExecutorOptions(
task.WithDir("testdata/env"),
task.WithSilent(true),
),
WithExperiment(&experiments.EnvPrecedence, 1),
)
}
func TestVars(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/vars"),
task.WithSilent(true),
),
)
NewExecutorTest(t,
WithName("cli-var-priority-default"),
WithExecutorOptions(
task.WithDir("testdata/vars"),
task.WithSilent(true),
),
WithTask("cli-var-priority"),
)
NewExecutorTest(t,
WithName("cli-var-priority-override"),
WithExecutorOptions(
task.WithDir("testdata/vars"),
task.WithSilent(true),
),
WithTask("cli-var-priority"),
WithVar("CLI_VAR", "from_cli"),
)
}
func TestSecretVars(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("secret vars are masked in logs"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
),
WithTask("test-secret-masking"),
)
NewExecutorTest(t,
WithName("multiple secrets masked"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
),
WithTask("test-multiple-secrets"),
)
NewExecutorTest(t,
WithName("mixed secret and public vars"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
),
WithTask("test-mixed"),
)
NewExecutorTest(t,
WithName("deferred command with secrets"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
),
WithTask("test-deferred-secret"),
)
NewExecutorTest(t,
WithName("env secret limitation"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
),
WithTask("test-env-secret-limitation"),
)
NewExecutorTest(t,
WithName("secret vars are masked in summary"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
task.WithSummary(true),
),
WithTask("test-secret-masking"),
)
NewExecutorTest(t,
WithName("dynamic secret masked in verbose"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
task.WithVerbose(true),
),
WithTask("test-dynamic-secret-verbose"),
)
NewExecutorTest(t,
WithName("secret key order independent"),
WithExecutorOptions(
task.WithDir("testdata/secrets"),
),
WithTask("test-secret-key-order"),
)
}
func TestRequires(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("required var missing"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("missing-var"),
WithRunError(),
)
NewExecutorTest(t,
WithName("required var ok"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("missing-var"),
WithVar("FOO", "bar"),
)
NewExecutorTest(t,
WithName("fails validation"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var"),
WithVar("ENV", "dev"),
WithVar("FOO", "bar"),
WithRunError(),
)
NewExecutorTest(t,
WithName("passes validation"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var"),
WithVar("FOO", "one"),
WithVar("ENV", "dev"),
)
NewExecutorTest(t,
WithName("required var missing + fails validation"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var"),
WithRunError(),
)
NewExecutorTest(t,
WithName("required var missing + fails validation"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var-dynamic"),
WithVar("FOO", "one"),
WithVar("ENV", "dev"),
)
NewExecutorTest(t,
WithName("require before compile"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("require-before-compile"),
WithRunError(),
)
NewExecutorTest(t,
WithName("var defined in task"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("var-defined-in-task"),
)
NewExecutorTest(t,
WithName("enum ref - passes validation"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var-ref"),
WithVar("ENV", "dev"),
)
NewExecutorTest(t,
WithName("enum ref - fails validation"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var-ref"),
WithVar("ENV", "invalid"),
WithRunError(),
)
NewExecutorTest(t,
WithName("enum ref - ref to non-list"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var-ref-invalid"),
WithVar("VALUE", "test"),
WithRunError(),
)
NewExecutorTest(t,
WithName("enum ref - ref to nonexistent var"),
WithExecutorOptions(
task.WithDir("testdata/requires"),
),
WithTask("validation-var-ref-nonexistent"),
WithVar("ENV", "dev"),
WithRunError(),
)
}
// TODO: mock fs
func TestSpecialVars(t *testing.T) {
t.Parallel()
const dir = "testdata/special_vars"
const subdir = "testdata/special_vars/subdir"
tests := []string{
// Root
"print-task",
"print-root-dir",
"print-root-taskfile",
"print-taskfile",
"print-taskfile-dir",
"print-task-dir",
// Included
"included:print-task",
"included:print-root-dir",
"included:print-taskfile",
"included:print-taskfile-dir",
}
for _, dir := range []string{dir, subdir} {
for _, test := range tests {
NewExecutorTest(t,
WithName(fmt.Sprintf("%s-%s", dir, test)),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
task.WithVersionCheck(true),
),
WithTask(test),
WithFixtureTemplating(),
)
}
}
}
func TestConcurrency(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/concurrency"),
task.WithConcurrency(1),
),
WithPostProcessFn(PPSortedLines),
)
}
func TestParams(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/params"),
task.WithSilent(true),
),
WithPostProcessFn(PPSortedLines),
)
}
func TestDeps(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/deps"),
task.WithSilent(true),
// Deps run in parallel and, with the default interleaved output,
// their sub-line writes (echo writes the content and the newline
// separately) can interleave into a garbled buffer. Group output
// flushes each command atomically, keeping every line intact. The
// set of lines asserted (via PPSortedLines) is unchanged.
task.WithOutputStyle(ast.Output{Name: "group"}),
),
WithPostProcessFn(PPSortedLines),
)
}
// TODO: mock fs
func TestStatus(t *testing.T) {
t.Parallel()
const dir = "testdata/status"
files := []string{
"foo.txt",
"bar.txt",
"baz.txt",
}
for _, f := range files {
path := filepathext.SmartJoin(dir, f)
_ = os.Remove(path)
if _, err := os.Stat(path); err == nil {
t.Errorf("File should not exist: %v", err)
}
}
// gen-foo creates foo.txt, and will always fail it's status check.
NewExecutorTest(t,
WithName("run gen-foo 1 silent"),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
),
WithTask("gen-foo"),
)
// gen-foo creates bar.txt, and will pass its status-check the 3. time it
// is run. It creates bar.txt, but also lists it as its source. So, the checksum
// for the file won't match before after the second run as we the file
// only exists after the first run.
NewExecutorTest(t,
WithName("run gen-bar 1 silent"),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
),
WithTask("gen-bar"),
)
// gen-silent-baz is marked as being silent, and should only produce output
// if e.Verbose is set to true.
NewExecutorTest(t,
WithName("run gen-baz silent"),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
),
WithTask("gen-silent-baz"),
)
for _, f := range files {
if _, err := os.Stat(filepathext.SmartJoin(dir, f)); err != nil {
t.Errorf("File should exist: %v", err)
}
}
// Run gen-bar a second time to produce a checksum file that matches bar.txt
NewExecutorTest(t,
WithName("run gen-bar 2 silent"),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
),
WithTask("gen-bar"),
)
// Run gen-bar a third time, to make sure we've triggered the status check.
NewExecutorTest(t,
WithName("run gen-bar 3 silent"),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
),
WithTask("gen-bar"),
)
// Now, let's remove source file, and run the task again to to prepare
// for the next test.
err := os.Remove(filepathext.SmartJoin(dir, "bar.txt"))
require.NoError(t, err)
NewExecutorTest(t,
WithName("run gen-bar 4 silent"),
WithExecutorOptions(
task.WithDir(dir),
task.WithSilent(true),
),
WithTask("gen-bar"),
)
// all: not up-to-date
NewExecutorTest(t,
WithName("run gen-foo 2"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("gen-foo"),
)
// status: not up-to-date
NewExecutorTest(t,
WithName("run gen-foo 3"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("gen-foo"),
)
// sources: not up-to-date
NewExecutorTest(t,
WithName("run gen-bar 5"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("gen-bar"),
)
// all: up-to-date
NewExecutorTest(t,
WithName("run gen-bar 6"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("gen-bar"),
)
// sources: not up-to-date, no output produced.
NewExecutorTest(t,
WithName("run gen-baz 2"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("gen-silent-baz"),
)
// up-to-date, no output produced
NewExecutorTest(t,
WithName("run gen-baz 3"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("gen-silent-baz"),
)
// up-to-date, output produced due to Verbose mode.
NewExecutorTest(t,
WithName("run gen-baz 4 verbose"),
WithExecutorOptions(
task.WithDir(dir),
task.WithVerbose(true),
),
WithTask("gen-silent-baz"),
WithFixtureTemplating(),
)
}
func TestPrecondition(t *testing.T) {
t.Parallel()
const dir = "testdata/precondition"
NewExecutorTest(t,
WithName("a precondition has been met"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("foo"),
)
NewExecutorTest(t,
WithName("a precondition was not met"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("impossible"),
WithRunError(),
)
NewExecutorTest(t,
WithName("precondition in dependency fails the task"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("depends_on_impossible"),
WithRunError(),
)
NewExecutorTest(t,
WithName("precondition in cmd fails the task"),
WithExecutorOptions(
task.WithDir(dir),
),
WithTask("executes_failing_task_as_cmd"),
WithRunError(),
)
}
func TestAlias(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("alias"),
WithExecutorOptions(
task.WithDir("testdata/alias"),
),
WithTask("f"),
)
NewExecutorTest(t,
WithName("duplicate alias"),
WithExecutorOptions(
task.WithDir("testdata/alias"),
),
WithTask("x"),
WithRunError(),
)
NewExecutorTest(t,
WithName("alias summary"),
WithExecutorOptions(
task.WithDir("testdata/alias"),
task.WithSummary(true),
),
WithTask("f"),
)
}
func TestSummaryWithVarsAndRequires(t *testing.T) {
t.Parallel()
// Test basic case from prompt.md - vars and requires
NewExecutorTest(t,
WithName("vars-and-requires"),
WithExecutorOptions(
task.WithDir("testdata/summary-vars-requires"),
task.WithSummary(true),
),
WithTask("mytask"),
)
// Test with shell variables
NewExecutorTest(t,
WithName("shell-vars"),
WithExecutorOptions(
task.WithDir("testdata/summary-vars-requires"),
task.WithSummary(true),
),
WithTask("with-sh-var"),
)
}
func TestLabel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("up to date"),
WithExecutorOptions(
task.WithDir("testdata/label_uptodate"),
),
WithTask("foo"),
)
NewExecutorTest(t,
WithName("summary"),
WithExecutorOptions(
task.WithDir("testdata/label_summary"),
task.WithSummary(true),
),
WithTask("foo"),
)
NewExecutorTest(t,
WithName("status"),
WithExecutorOptions(
task.WithDir("testdata/label_status"),
),
WithTask("foo"),
WithStatusError(),
)
NewExecutorTest(t,
WithName("var"),
WithExecutorOptions(
task.WithDir("testdata/label_var"),
),
WithTask("foo"),
)
NewExecutorTest(t,
WithName("label in summary"),
WithExecutorOptions(
task.WithDir("testdata/label_summary"),
),
WithTask("foo"),
)
NewExecutorTest(t,
WithName("label in error"),
WithExecutorOptions(
task.WithDir("testdata/label_error"),
),
WithTask("foo"),
WithRunError(),
)
}
func TestPrefix(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("up to date"),
WithExecutorOptions(
task.WithDir("testdata/prefix_uptodate"),
task.WithOutputStyle(ast.Output{Name: "prefixed"}),
),
WithTask("foo"),
)
NewExecutorTest(t,
WithName("up to dat with no output style"),
WithExecutorOptions(
task.WithDir("testdata/prefix_uptodate"),
),
WithTask("foo"),
)
}
func TestPromptInSummary(t *testing.T) {
t.Parallel()
tests := []struct {
name string
input string
wantError bool
}{
{"test short approval", "y\n", false},
{"test long approval", "yes\n", false},
{"test uppercase approval", "Y\n", false},
{"test stops task", "n\n", true},
{"test junk value stops task", "foobar\n", true},
{"test Enter stops task", "\n", true},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
t.Parallel()
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/prompt"),
task.WithAssumeTerm(true),
),
WithTask("foo"),
WithInput(test.input),
}
if test.wantError {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
})
}
}
func TestPromptWithIndirectTask(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/prompt"),
task.WithAssumeTerm(true),
),
WithTask("bar"),
WithInput("y\n"),
)
}
func TestPromptAssumeYes(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("--yes flag should skip prompt"),
WithExecutorOptions(
task.WithDir("testdata/prompt"),
task.WithAssumeTerm(true),
task.WithAssumeYes(true),
),
WithTask("foo"),
WithInput("\n"),
)
NewExecutorTest(t,
WithName("task should raise errors.TaskCancelledError"),
WithExecutorOptions(
task.WithDir("testdata/prompt"),
task.WithAssumeTerm(true),
),
WithTask("foo"),
WithInput("\n"),
WithRunError(),
)
}
func TestForCmds(t *testing.T) {
t.Parallel()
tests := []struct {
name string
wantErr bool
}{
{name: "loop-explicit"},
{name: "loop-matrix"},
{name: "loop-matrix-ref"},
{name: "loop-matrix-ref-computed"},
{
name: "loop-matrix-ref-error",
wantErr: true,
},
{name: "loop-sources"},
{name: "loop-sources-glob"},
{name: "loop-generates"},
{name: "loop-generates-glob"},
{name: "loop-vars"},
{name: "loop-vars-sh"},
{name: "loop-task"},
{name: "loop-task-as"},
{name: "loop-different-tasks"},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/for/cmds"),
task.WithSilent(true),
task.WithForce(true),
),
WithTask(test.name),
WithFixtureTemplating(),
}
if test.wantErr {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestForDeps(t *testing.T) {
t.Parallel()
tests := []struct {
name string
wantErr bool
}{
{name: "loop-explicit"},
{name: "loop-matrix"},
{name: "loop-matrix-ref"},
{
name: "loop-matrix-ref-error",
wantErr: true,
},
{name: "loop-sources"},
{name: "loop-sources-glob"},
{name: "loop-generates"},
{name: "loop-generates-glob"},
{name: "loop-vars"},
{name: "loop-vars-sh"},
{name: "loop-task"},
{name: "loop-task-as"},
{name: "loop-different-tasks"},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/for/deps"),
task.WithSilent(true),
task.WithForce(true),
// Force output of each dep to be grouped together to prevent interleaving
task.WithOutputStyle(ast.Output{Name: "group"}),
),
WithTask(test.name),
WithFixtureTemplating(),
WithPostProcessFn(PPSortedLines),
}
if test.wantErr {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestReference(t *testing.T) {
t.Parallel()
tests := []struct {
name string
call string
}{
{
name: "reference in command",
call: "ref-cmd",
},
{
name: "reference in dependency",
call: "ref-dep",
},
{
name: "reference using templating resolver",
call: "ref-resolver",
},
{
name: "reference using templating resolver and dynamic var",
call: "ref-resolver-sh",
},
}
for _, test := range tests {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/var_references"),
task.WithSilent(true),
task.WithForce(true),
),
WithTask(cmp.Or(test.call, "default")),
)
}
}
func TestVarInheritance(t *testing.T) {
tests := []struct {
name string
call string
}{
{name: "shell"},
{name: "entrypoint-global-dotenv"},
{name: "entrypoint-global-vars"},
// We can't send env vars to a called task, so the env var is not overridden
{name: "entrypoint-task-call-vars"},
// Dotenv doesn't set variables
{name: "entrypoint-task-call-dotenv"},
{name: "entrypoint-task-call-task-vars"},
// Dotenv doesn't set variables
{name: "entrypoint-task-dotenv"},
{name: "entrypoint-task-vars"},
// {
// // Dotenv not currently allowed in included taskfiles
// name: "included-global-dotenv",
// want: "included-global-dotenv\nincluded-global-dotenv\n",
// },
{
name: "included-global-vars",
call: "included",
},
{
// We can't send env vars to a called task, so the env var is not overridden
name: "included-task-call-vars",
call: "included",
},
{
// Dotenv doesn't set variables
// Dotenv not currently allowed in included taskfiles (but doesn't error in a task)
name: "included-task-call-dotenv",
call: "included",
},
{
name: "included-task-call-task-vars",
call: "included",
},
{
// Dotenv doesn't set variables
// Somehow dotenv is working here!
name: "included-task-dotenv",
call: "included",
},
{
name: "included-task-vars",
call: "included",
},
}
t.Setenv("VAR", "shell")
t.Setenv("ENV", "shell")
for _, test := range tests {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(
task.WithDir(fmt.Sprintf("testdata/var_inheritance/v3/%s", test.name)),
task.WithSilent(true),
task.WithForce(true),
),
WithTask(cmp.Or(test.call, "default")),
WithExperiment(&experiments.EnvPrecedence, 1),
)
}
}
func TestFuzzyModel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("fuzzy"),
WithExecutorOptions(
task.WithDir("testdata/fuzzy"),
),
WithTask("instal"),
WithRunError(),
)
NewExecutorTest(t,
WithName("not-fuzzy"),
WithExecutorOptions(
task.WithDir("testdata/fuzzy"),
),
WithTask("install"),
)
NewExecutorTest(t,
WithName("intern"),
WithExecutorOptions(
task.WithDir("testdata/fuzzy"),
),
WithTask("intern"),
WithRunError(),
)
}
func TestIncludeChecksum(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("correct"),
WithExecutorOptions(
task.WithDir("testdata/includes_checksum/correct"),
),
)
NewExecutorTest(t,
WithName("incorrect"),
WithExecutorOptions(
task.WithDir("testdata/includes_checksum/incorrect"),
),
WithSetupError(),
WithFixtureTemplating(),
)
}
// writeFile writes content to a file, creating any intermediate directories.
func writeFile(t *testing.T, dir, name, content string) {
t.Helper()
require.NoError(t, os.WriteFile(filepathext.SmartJoin(dir, name), []byte(content), 0o644))
}
// gitignoreStep writes a set of files then runs the task once, capturing its
// output as a golden fixture named run.
type gitignoreStep struct {
write map[string]string
run string
}
// gitignoreSeq drives a checksum task through a sequence of runs against a
// fixture dir. create seeds runtime files (removed on cleanup); restore resets
// tracked files to their committed content on cleanup; artifacts are
// task-produced files to delete on cleanup.
type gitignoreSeq struct {
dir string
task string
create map[string]string
restore map[string]string
artifacts []string
steps []gitignoreStep
}
func (s gitignoreSeq) run(t *testing.T) {
t.Helper()
cleanup := func() {
// The fixture manages its own .git marker so that gitignore filtering
// resolves a repo root regardless of the build source: an in-tree
// checkout would otherwise inherit the go-task .git, but a GitHub
// source tarball has none, which would silently disable filtering and
// break the golden fixtures.
_ = os.RemoveAll(filepathext.SmartJoin(s.dir, ".git"))
_ = os.RemoveAll(filepathext.SmartJoin(s.dir, ".task"))
for name := range s.create {
_ = os.Remove(filepathext.SmartJoin(s.dir, name))
}
for _, name := range s.artifacts {
_ = os.Remove(filepathext.SmartJoin(s.dir, name))
}
for name, content := range s.restore {
writeFile(t, s.dir, name, content)
}
}
cleanup()
t.Cleanup(cleanup)
require.NoError(t, os.MkdirAll(filepathext.SmartJoin(s.dir, ".git"), 0o755))
for name, content := range s.create {
writeFile(t, s.dir, name, content)
}
for _, step := range s.steps {
for name, content := range step.write {
writeFile(t, s.dir, name, content)
}
NewExecutorTest(t,
WithName(step.run),
WithExecutorOptions(task.WithDir(s.dir)),
WithTask(s.task),
)
}
}
func TestGitignoreChecksum(t *testing.T) { //nolint:paralleltest // shares testdata/gitignore and mutates fixture files
gitignoreSeq{
dir: "testdata/gitignore",
task: "build",
create: map[string]string{"ignored.txt": "ignored\n"},
restore: map[string]string{"source.txt": "source content\n"},
artifacts: []string{"generated.txt"},
steps: []gitignoreStep{
{run: "first run"},
{run: "up to date"},
{run: "ignored file modified", write: map[string]string{"ignored.txt": "ignored modified\n"}},
{run: "source file modified", write: map[string]string{"source.txt": "source modified\n"}},
},
}.run(t)
}
// TestGitignoreNegation checks that a `!pattern` in a nested .gitignore
// re-includes a file excluded by a parent .gitignore.
func TestGitignoreNegation(t *testing.T) { //nolint:paralleltest // mutates fixture files
gitignoreSeq{
dir: "testdata/gitignore_negation",
task: "build",
create: map[string]string{"sub/debug.log": "debug\n", "sub/other.log": "other\n"},
steps: []gitignoreStep{
{run: "first run"},
{run: "up to date"},
{run: "ignored file modified", write: map[string]string{"sub/other.log": "other modified\n"}},
{run: "reincluded file modified", write: map[string]string{"sub/debug.log": "debug modified\n"}},
},
}.run(t)
}
// TestGitignoreNested checks that a .gitignore in a subdirectory below the task
// dir is honored when its files are reached by a deep glob.
func TestGitignoreNested(t *testing.T) { //nolint:paralleltest // mutates fixture files
gitignoreSeq{
dir: "testdata/gitignore_nested",
task: "build",
create: map[string]string{"sub/secret.dat": "secret\n"},
restore: map[string]string{"sub/keep.txt": "keep\n"},
steps: []gitignoreStep{
{run: "first run"},
{run: "up to date"},
{run: "ignored file modified", write: map[string]string{"sub/secret.dat": "secret modified\n"}},
{run: "source file modified", write: map[string]string{"sub/keep.txt": "keep modified\n"}},
},
}.run(t)
}
// TestGitignoreIncluded checks that a top-level use_gitignore in an included
// Taskfile is propagated onto its tasks during merge.
func TestGitignoreIncluded(t *testing.T) { //nolint:paralleltest // mutates fixture files
gitignoreSeq{
dir: "testdata/gitignore_included",
task: "included:build",
create: map[string]string{"ignored.txt": "ignored\n"},
steps: []gitignoreStep{
{run: "first run"},
{run: "up to date"},
{run: "ignored file modified", write: map[string]string{"ignored.txt": "ignored modified\n"}},
},
}.run(t)
}
// TestGitignoreIncludedOverride checks that an explicit use_gitignore: false in
// an included Taskfile is preserved even when the root Taskfile sets it to true.
func TestGitignoreIncludedOverride(t *testing.T) { //nolint:paralleltest // mutates fixture files
gitignoreSeq{
dir: "testdata/gitignore_included_override",
task: "included:build",
create: map[string]string{"ignored.txt": "ignored\n"},
steps: []gitignoreStep{
{run: "first run"},
{run: "up to date"},
{run: "ignored file modified", write: map[string]string{"ignored.txt": "ignored modified\n"}},
},
}.run(t)
}
func TestIncludeSilent(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("include-taskfile-silent"),
WithExecutorOptions(
task.WithDir("testdata/includes_silent"),
),
WithTask("default"),
)
}
func TestFailfast(t *testing.T) {
t.Parallel()
t.Run("Default", func(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("default"),
WithExecutorOptions(
task.WithDir("testdata/failfast/default"),
task.WithSilent(true),
),
WithPostProcessFn(PPSortedLines),
WithRunError(),
)
})
t.Run("Option", func(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("default"),
WithExecutorOptions(
task.WithDir("testdata/failfast/default"),
task.WithSilent(true),
task.WithFailfast(true),
),
WithPostProcessFn(PPSortedLines),
WithRunError(),
)
})
t.Run("Task", func(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("task"),
WithExecutorOptions(
task.WithDir("testdata/failfast/task"),
task.WithSilent(true),
),
WithPostProcessFn(PPSortedLines),
WithRunError(),
)
})
}
func TestIf(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
vars map[string]any
verbose bool
}{
// Basic command-level if
{name: "cmd-if-true", task: "cmd-if-true"},
{name: "cmd-if-false", task: "cmd-if-false"},
// Task-level if
{name: "task-if-true", task: "task-if-true"},
{name: "task-if-false", task: "task-if-false", verbose: true},
// Task call with if
{name: "task-call-if-true", task: "task-call-if-true"},
{name: "task-call-if-false", task: "task-call-if-false", verbose: true},
// Go template conditions
{name: "template-eq-true", task: "template-eq-true"},
{name: "template-eq-false", task: "template-eq-false", verbose: true},
{name: "template-ne", task: "template-ne"},
{name: "template-bool-true", task: "template-bool-true"},
{name: "template-bool-false", task: "template-bool-false"},
{name: "template-direct-true", task: "template-direct-true"},
{name: "template-direct-false", task: "template-direct-false"},
{name: "template-and", task: "template-and"},
{name: "template-or", task: "template-or"},
// CLI variable override
{name: "template-cli-var", task: "template-cli-var", vars: map[string]any{"MY_VAR": "yes"}},
// Task-level if with template
{name: "task-level-template", task: "task-level-template"},
{name: "task-level-template-false", task: "task-level-template-false", verbose: true},
// For loop with if
{name: "if-in-for-loop", task: "if-in-for-loop", verbose: true},
// Task-level if with dynamic variable
{name: "task-if-dynamic-true", task: "task-if-dynamic-true"},
{name: "task-if-dynamic-false", task: "task-if-dynamic-false", verbose: true},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/if"),
task.WithSilent(true),
task.WithVerbose(test.verbose),
),
WithTask(test.task),
}
if test.vars != nil {
for k, v := range test.vars {
opts = append(opts, WithVar(k, v))
}
}
NewExecutorTest(t, opts...)
}
}
func TestIncludes(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes")),
)
}
func TestIncludesMultiLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_multi_level")),
)
}
func TestIncludesEmptyMain(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_empty")),
WithTask("included:default"),
)
}
func TestIncludesDependencies(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_deps")),
)
}
func TestIncludesCallingRoot(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_call_root_task")),
WithTask("included:call-root"),
)
}
func TestIncludesOptional(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_optional")),
)
}
func TestIncludesFromCustomTaskfile(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/includes_yaml"),
task.WithEntrypoint("testdata/includes_yaml/Custom.ext"),
),
)
}
func TestIncludesShadowedDefault(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_shadowed_default")),
WithTask("included"),
)
}
func TestIncludesUnshadowedDefault(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_unshadowed_default")),
WithTask("included"),
)
}
func TestIncludesRemote(t *testing.T) {
dir := "testdata/includes_remote"
os.RemoveAll(filepath.Join(dir, ".task", "remote"))
srv := httptest.NewServer(http.FileServer(http.Dir(dir)))
defer srv.Close()
tcs := []struct {
firstRemote string
secondRemote string
}{
{
firstRemote: srv.URL + "/first/Taskfile.yml",
secondRemote: srv.URL + "/first/second/Taskfile.yml",
},
{
firstRemote: srv.URL + "/first/Taskfile.yml",
secondRemote: "./second/Taskfile.yml",
},
{
firstRemote: srv.URL + "/first/",
secondRemote: srv.URL + "/first/second/",
},
}
taskCalls := []*task.Call{
{Task: "first:write-file"},
{Task: "first:second:write-file"},
}
for i, tc := range tcs {
t.Run(fmt.Sprint(i), func(t *testing.T) {
t.Setenv("FIRST_REMOTE_URL", tc.firstRemote)
t.Setenv("SECOND_REMOTE_URL", tc.secondRemote)
var buff SyncBuffer
// Extract host from server URL for trust testing
parsedURL, err := url.Parse(srv.URL)
require.NoError(t, err)
trustedHost := parsedURL.Host
executors := []struct {
name string
executor *task.Executor
}{
{
name: "online, always download",
executor: task.NewExecutor(
task.WithDir(dir),
task.WithStdout(&buff),
task.WithStderr(&buff),
task.WithTimeout(time.Minute),
task.WithInsecure(true),
task.WithStdout(&buff),
task.WithStderr(&buff),
task.WithVerbose(true),
// Without caching
task.WithAssumeYes(true),
task.WithDownload(true),
),
},
{
name: "offline, use cache",
executor: task.NewExecutor(
task.WithDir(dir),
task.WithStdout(&buff),
task.WithStderr(&buff),
task.WithTimeout(time.Minute),
task.WithInsecure(true),
task.WithStdout(&buff),
task.WithStderr(&buff),
task.WithVerbose(true),
// With caching
task.WithAssumeYes(false),
task.WithDownload(false),
task.WithOffline(true),
),
},
{
name: "with trusted hosts, no prompts",
executor: task.NewExecutor(
task.WithDir(dir),
task.WithStdout(&buff),
task.WithStderr(&buff),
task.WithTimeout(time.Minute),
task.WithInsecure(true),
task.WithStdout(&buff),
task.WithStderr(&buff),
task.WithVerbose(true),
// With trusted hosts
task.WithTrustedHosts([]string{trustedHost}),
task.WithDownload(true),
),
},
}
for _, e := range executors {
t.Run(e.name, func(t *testing.T) {
require.NoError(t, e.executor.Setup())
for k, taskCall := range taskCalls {
t.Run(taskCall.Task, func(t *testing.T) {
expectedContent := fmt.Sprint(rand.Int64()) //nolint:gosec
t.Setenv("CONTENT", expectedContent)
outputFile := fmt.Sprintf("%d.%d.txt", i, k)
t.Setenv("OUTPUT_FILE", outputFile)
path := filepath.Join(dir, outputFile)
require.NoError(t, os.RemoveAll(path))
require.NoError(t, e.executor.Run(t.Context(), taskCall))
actualContent, err := os.ReadFile(path)
require.NoError(t, err)
assert.Equal(t, expectedContent, strings.TrimSpace(string(actualContent)))
})
}
})
}
t.Log("\noutput:\n", buff.buf.String())
})
}
}
func TestIncludesHttp(t *testing.T) { //nolint:paralleltest // sets INCLUDE_ROOT per iteration
dir, err := filepath.Abs("testdata/includes_http")
require.NoError(t, err)
srv := httptest.NewServer(http.FileServer(http.Dir(dir)))
defer srv.Close()
t.Cleanup(func() {
// This test fills the .task/remote directory with cache entries because the include URL
// is different on every test due to the dynamic nature of the TCP port in srv.URL
if err := os.RemoveAll(filepath.Join(dir, ".task")); err != nil {
t.Logf("error cleaning up: %s", err)
}
})
taskfiles, err := fs.Glob(os.DirFS(dir), "root-taskfile-*.yml")
require.NoError(t, err)
remotes := []struct {
name string
root string
}{
{
name: "local",
root: ".",
},
{
name: "http-remote",
root: srv.URL,
},
}
tcs := []struct {
name, dir string
}{
{
name: "second-with-dir-1:third-with-dir-1:default",
dir: filepath.Join(dir, "dir-1"),
},
{
name: "second-with-dir-1:third-with-dir-2:default",
dir: filepath.Join(dir, "dir-2"),
},
}
for _, taskfile := range taskfiles {
for _, remote := range remotes { //nolint:paralleltest // sets INCLUDE_ROOT per iteration
t.Setenv("INCLUDE_ROOT", remote.root)
NewExecutorTest(t,
WithName(fmt.Sprintf("%s/%s", taskfile, remote.name)),
WithExecutorOptions(
task.WithEntrypoint(filepath.Join(dir, taskfile)),
task.WithDir(dir),
task.WithInsecure(true),
task.WithDownload(true),
task.WithAssumeYes(true),
task.WithVerbose(true),
task.WithTimeout(time.Minute),
),
WithNoRun(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
for _, tc := range tcs {
compiled, err := r.Executor.CompiledTask(&task.Call{Task: tc.name})
require.NoError(t, err)
assert.Equal(t, tc.dir, compiled.Dir)
}
}),
)
}
}
}
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()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir(fmt.Sprintf("testdata/file_names/%s", fileName))),
)
})
}
}
func TestDynamicVariablesShouldRunOnTheTaskDir(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dir/dynamic_var")),
)
}
func TestDotenvShouldIncludeAllEnvFiles(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv/default")),
)
}
func TestDotenvShouldAllowMissingEnv(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv/missing_env")),
)
}
func TestDotenvHasLocalEnvInPath(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv/local_env_in_path")),
)
}
func TestDotenvHasLocalVarInPath(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv/local_var_in_path")),
)
}
func TestDotenvHasEnvVarInPath(t *testing.T) { // nolint:paralleltest // cannot run in parallel
t.Setenv("ENV_VAR", "testing")
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv/env_var_in_path")),
)
}
func TestTaskDotenv(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv_task/default")),
WithTask("dotenv"),
)
}
func TestTaskDotenvFail(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv_task/default")),
WithTask("no-dotenv"),
)
}
func TestTaskDotenvOverriddenByEnv(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv_task/default")),
WithTask("dotenv-overridden-by-env"),
)
}
func TestTaskDotenvWithVarName(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv_task/default")),
WithTask("dotenv-with-var-name"),
)
}
func TestRunOnlyRunsJobsHashOnce(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/run")),
WithTask("generate-hash"),
)
}
func TestRunOnlyRunsJobsHashOnceWithWildcard(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/run")),
WithTask("deploy"),
)
}
func TestSingleCmdDep(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/single_cmd_dep")),
WithTask("foo"),
)
}
func TestShortTaskNotation(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/short_task_notation"),
task.WithSilent(true),
),
)
}
func TestExitCodeZero(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/exit_code")),
WithTask("exit-zero"),
)
}
func TestExitCodeOne(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/exit_code")),
WithTask("exit-one"),
WithRunError(),
)
}
func TestOutputGroup(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/output_group")),
WithTask("bye"),
)
}
func TestOutputGroupErrorOnlySwallowsOutputOnSuccess(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/output_group_error_only")),
WithTask("passing"),
)
}
func TestOutputGroupErrorOnlyShowsOutputOnFailure(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/output_group_error_only")),
WithTask("failing"),
WithRunError(),
)
}
func TestIncludedVars(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/include_with_vars")),
WithTask("task1"),
)
}
func TestIncludedVarsMultiLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/include_with_vars_multi_level")),
)
}
func TestTaskfileWalk(t *testing.T) {
t.Parallel()
tests := []struct {
name string
dir string
}{
{name: "walk from root directory", dir: "testdata/taskfile_walk"},
{name: "walk from sub directory", dir: "testdata/taskfile_walk/foo"},
{name: "walk from sub sub directory", dir: "testdata/taskfile_walk/foo/bar"},
}
for _, test := range tests {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(task.WithDir(test.dir)),
)
}
}
func TestPOSIXShellOptsGlobalLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/shopts/global_level")),
WithTask("pipefail"),
)
}
func TestPOSIXShellOptsTaskLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/shopts/task_level")),
WithTask("pipefail"),
)
}
func TestPOSIXShellOptsCommandLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/shopts/command_level")),
WithTask("pipefail"),
)
}
func TestBashShellOptsGlobalLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/shopts/global_level")),
WithTask("globstar"),
)
}
func TestBashShellOptsTaskLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/shopts/task_level")),
WithTask("globstar"),
)
}
func TestBashShellOptsCommandLevel(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/shopts/command_level")),
WithTask("globstar"),
)
}
func TestSplitArgs(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/split_args"),
task.WithSilent(true),
),
WithVar("CLI_ARGS", "foo bar 'foo bar baz'"),
)
}
func TestWildcard(t *testing.T) {
t.Parallel()
tests := []struct {
name string
call string
wantErr bool
}{
{name: "basic wildcard", call: "wildcard-foo"},
{name: "double wildcard", call: "foo-wildcard-bar"},
{name: "store wildcard", call: "start-foo"},
{name: "alias", call: "s-foo"},
{name: "matches exactly", call: "matches-exactly-*"},
{name: "no matches", call: "no-match", wantErr: true},
{name: "multiple matches", call: "wildcard-foo-bar"},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.call),
WithExecutorOptions(
task.WithDir("testdata/wildcards"),
task.WithSilent(true),
task.WithForce(true),
),
WithTask(test.call),
}
if test.wantErr {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
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 {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(
task.WithDir(test.dir),
task.WithSilent(true),
),
)
}
}
func TestRunWhenChanged(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/run_when_changed"),
task.WithForceAll(true),
task.WithSilent(true),
),
WithTask("start"),
)
}
func TestRunOnceSharedFailurePropagates(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/run_once_failure")),
WithRunError(),
)
}
func TestForce(t *testing.T) {
t.Parallel()
tests := []struct {
name string
force bool
forceAll bool
}{
{name: "force", force: true},
{name: "force-all", forceAll: true},
{name: "force with gentle force experiment", force: true},
{name: "force-all with gentle force experiment", forceAll: true},
}
for _, tt := range tests {
NewExecutorTest(t,
WithName(tt.name),
WithExecutorOptions(
task.WithDir("testdata/force"),
task.WithForce(tt.force),
task.WithForceAll(tt.forceAll),
),
WithTask("task-with-dep"),
)
}
}
func TestIncludesInternal(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
expectedErr bool
}{
{"included internal task via task", "task-1", false},
{"included internal task via dep", "task-2", false},
{"included internal direct", "included:task-3", true},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/internal_task"),
task.WithSilent(true),
),
WithTask(test.task),
}
if test.expectedErr {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestInternalTask(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
expectedErr bool
}{
{"internal task via task", "task-1", false},
{"internal task via dep", "task-2", false},
{"internal direct", "task-3", true},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/internal_task"),
task.WithSilent(true),
),
WithTask(test.task),
}
if test.expectedErr {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestIncludesInterpolation(t *testing.T) { // nolint:paralleltest // cannot run in parallel
const dir = "testdata/includes_interpolation"
tests := []struct {
name string
task string
}{
{"include", "include"},
{"include_with_env_variable", "include-with-env-variable"},
{"include_with_dir", "include-with-dir"},
}
t.Setenv("MODULE", "included")
for _, test := range tests { // nolint:paralleltest // cannot run in parallel
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(
task.WithDir(filepath.Join(dir, test.name)),
task.WithSilent(true),
),
WithTask(test.task),
)
}
}
func TestIncludesFlatten(t *testing.T) {
t.Parallel()
const dir = "testdata/includes_flatten"
tests := []struct {
name string
taskfile string
task string
expectedErr bool
}{
{name: "included flatten", taskfile: "Taskfile.yml", task: "gen"},
{name: "included flatten with default", taskfile: "Taskfile.yml", task: "default"},
{name: "included flatten can call entrypoint tasks", taskfile: "Taskfile.yml", task: "from_entrypoint"},
{name: "included flatten with deps", taskfile: "Taskfile.yml", task: "with_deps"},
{name: "included flatten nested", taskfile: "Taskfile.yml", task: "from_nested"},
{name: "included flatten multiple same task", taskfile: "Taskfile.multiple.yml", task: "gen", expectedErr: true},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir(dir),
task.WithEntrypoint(dir+"/"+test.taskfile),
task.WithSilent(true),
),
WithTask(test.task),
}
if test.expectedErr {
opts = append(opts, WithSetupError())
}
NewExecutorTest(t, opts...)
}
}
func TestTaskIgnoreErrors(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("task-should-pass"),
WithExecutorOptions(task.WithDir("testdata/ignore_errors")),
WithTask("task-should-pass"),
)
NewExecutorTest(t,
WithName("task-should-fail"),
WithExecutorOptions(task.WithDir("testdata/ignore_errors")),
WithTask("task-should-fail"),
WithRunError(),
)
NewExecutorTest(t,
WithName("cmd-should-pass"),
WithExecutorOptions(task.WithDir("testdata/ignore_errors")),
WithTask("cmd-should-pass"),
)
NewExecutorTest(t,
WithName("cmd-should-fail"),
WithExecutorOptions(task.WithDir("testdata/ignore_errors")),
WithTask("cmd-should-fail"),
WithRunError(),
)
}
func TestDeferredCmds(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("task-2"),
WithExecutorOptions(task.WithDir("testdata/deferred")),
WithTask("task-2"),
WithRunError(),
)
NewExecutorTest(t,
WithName("parent"),
WithExecutorOptions(task.WithDir("testdata/deferred")),
WithTask("parent"),
)
}
func TestIncludeCycle(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/includes_cycle"),
task.WithSilent(true),
),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestIncludesIncorrect(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/includes_incorrect"),
task.WithSilent(true),
),
WithSetupError(),
)
}
func TestIncludesMissingTaskfile(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/includes_missing_taskfile"),
task.WithSilent(true),
),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestIncludesOptionalImplicitFalse(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_optional_implicit_false")),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestIncludesOptionalExplicitFalse(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/includes_optional_explicit_false")),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestDotenvShouldErrorWhenIncludingDependantDotenvs(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/dotenv/error_included_envs"),
task.WithSummary(true),
),
WithSetupError(),
)
}
func TestTaskDotenvParseErrorMessage(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dotenv/parse_error")),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestDisplaysErrorOnVersion1Schema(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/version/v1"),
task.WithVersionCheck(true),
),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestDisplaysErrorOnVersion2Schema(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/version/v2"),
task.WithVersionCheck(true),
),
WithSetupError(),
WithFixtureTemplating(),
)
}
func TestExpand(t *testing.T) {
t.Parallel()
home, err := os.UserHomeDir()
require.NoError(t, err)
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/expand")),
WithTask("pwd"),
WithFixtureTemplateData("HOME", filepath.ToSlash(home)),
)
}
func TestUserWorkingDirectory(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/user_working_dir")),
WithFixtureTemplating(),
)
}
func TestAbsPath(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/abs_path"),
task.WithSilent(true),
),
WithFixtureTemplating(),
)
}
func TestPlatforms(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/platforms")),
WithTask("build-"+runtime.GOOS),
WithFixtureTemplateData("GOOS", runtime.GOOS),
)
}
func TestIncludedTaskfileVarMerging(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
}{
{"foo", "foo:pwd"},
{"bar", "bar:pwd"},
}
for _, test := range tests {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/included_taskfile_var_merging"),
task.WithSilent(true),
),
WithTask(test.task),
WithFixtureTemplating(),
)
}
}
func TestIncludesRelativePath(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("common:pwd"),
WithExecutorOptions(task.WithDir("testdata/includes_rel_path")),
WithTask("common:pwd"),
WithFixtureTemplating(),
)
NewExecutorTest(t,
WithName("included:common:pwd"),
WithExecutorOptions(task.WithDir("testdata/includes_rel_path")),
WithTask("included:common:pwd"),
WithFixtureTemplating(),
)
}
func TestWhenNoDirAttributeItRunsInSameDirAsTaskfile(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dir")),
WithTask("whereami"),
WithFixtureTemplating(),
)
}
func TestWhenDirAttributeAndDirExistsItRunsInThatDir(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dir/explicit_exists")),
WithTask("whereami"),
WithFixtureTemplating(),
)
}
func TestWhenDirAttributeItCreatesMissingAndRunsInThatDir(t *testing.T) {
t.Parallel()
const toBeCreated = "testdata/dir/explicit_doesnt_exist/createme"
// 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)
}
t.Cleanup(func() { _ = os.RemoveAll(toBeCreated) })
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dir/explicit_doesnt_exist/")),
WithTask("whereami"),
WithFixtureTemplating(),
)
}
func TestDynamicVariablesRunOnTheNewCreatedDir(t *testing.T) {
t.Parallel()
const toBeCreated = "testdata/dir/dynamic_var_on_created_dir/created"
// 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)
}
t.Cleanup(func() { _ = os.RemoveAll(toBeCreated) })
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/dir/dynamic_var_on_created_dir")),
WithFixtureTemplating(),
// Take only the first line, as Windows may output additional debug info.
WithPostProcessFn(PPFirstLine),
)
}
func TestEvaluateSymlinksInPaths(t *testing.T) { // nolint:paralleltest // cannot run in parallel
const dir = "testdata/evaluate_symlinks_in_paths"
t.Cleanup(func() {
_ = os.RemoveAll(dir + "/.task")
})
steps := []struct {
name string
task string
}{
{"default (1)", "default"},
{"test-sym (1)", "test-sym"},
{"default (2)", "default"},
{"default (3)", "default"},
{"reset", "reset"},
}
for _, step := range steps { // nolint:paralleltest // cannot run in parallel
NewExecutorTest(t,
WithName(step.name),
WithExecutorOptions(task.WithDir(dir)),
WithTask(step.task),
)
}
}
func TestIgnoreErrorsOnTimeout(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
expectError bool
}{
{name: "ignored at task level", task: "task-timeout-should-pass"},
{name: "ignored at command level", task: "cmd-timeout-should-pass"},
{name: "not ignored", task: "cmd-timeout-should-fail", expectError: true},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(task.WithDir("testdata/ignore_errors")),
WithTask(test.task),
}
if test.expectError {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestExitImmediately(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/exit_immediately"),
task.WithSilent(true),
),
WithRunError(),
)
}
func TestRunOnceSharedDeps(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/run_once_shared_deps"),
task.WithForceAll(true),
),
WithTask("build"),
// service-a:build and service-b:build run concurrently, so their
// output can interleave in either order, and whichever of them wins
// the race is credited with the shared "run: once" library:build dep.
WithPostProcessFn(func(t *testing.T, b []byte) []byte {
t.Helper()
re := regexp.MustCompile(`service-[ab]:library:build`)
return re.ReplaceAll(b, []byte("service-x:library:build"))
}),
WithPostProcessFn(PPSortedLines),
)
}
func TestCommandTimeout(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
expectError bool
}{
{name: "timeout exceeded", task: "timeout-exceeded", expectError: true},
{name: "timeout not exceeded", task: "timeout-not-exceeded"},
{name: "no timeout", task: "no-timeout"},
{name: "multiple commands with timeout", task: "multiple-cmds-timeout", expectError: true},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(task.WithDir("testdata/timeout")),
WithTask(test.task),
}
if test.expectError {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestIncludesWithExclude(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
expectError bool
}{
{name: "included:bar", task: "included:bar"},
{name: "included:foo", task: "included:foo", expectError: true},
{name: "included:foo:child", task: "included:foo:child"},
{name: "included:namespace", task: "included:namespace"},
{name: "included:namespace:one", task: "included:namespace:one", expectError: true},
{name: "included:namespace-other:one", task: "included:namespace-other:one"},
{name: "bar", task: "bar", expectError: true},
{name: "foo", task: "foo"},
{name: "namespace", task: "namespace"},
{name: "namespace:two", task: "namespace:two", expectError: true},
{name: "namespace-other:one", task: "namespace-other:one"},
}
for _, test := range tests {
opts := []ExecutorTestOption{
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/includes_with_excludes"),
task.WithSilent(true),
),
WithTask(test.task),
}
if test.expectError {
opts = append(opts, WithRunError())
}
NewExecutorTest(t, opts...)
}
}
func TestCyclicDep(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/cyclic")),
WithTask("task-1"),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
var taskCalledTooManyTimesError *errors.TaskCalledTooManyTimesError
assert.ErrorAs(t, r.Err, &taskCalledTooManyTimesError)
}),
)
}
func TestTaskVersion(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("v1"),
WithExecutorOptions(
task.WithDir("testdata/version/v1"),
task.WithVersionCheck(true),
),
WithSetupError(),
WithFixtureTemplating(),
)
NewExecutorTest(t,
WithName("v2"),
WithExecutorOptions(
task.WithDir("testdata/version/v2"),
task.WithVersionCheck(true),
),
WithSetupError(),
WithFixtureTemplating(),
)
NewExecutorTest(t,
WithName("v3"),
WithExecutorOptions(
task.WithDir("testdata/version/v3"),
task.WithVersionCheck(true),
),
WithNoRun(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Equal(t, semver.MustParse("3"), r.Executor.Taskfile.Version)
assert.Equal(t, 2, r.Executor.Taskfile.Tasks.Len())
}),
)
}
func TestDry(t *testing.T) {
t.Parallel()
_ = os.Remove(filepathext.SmartJoin("testdata/dry", "file.txt"))
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/dry"),
task.WithDry(true),
),
WithTask("build"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
_, err := os.Stat(filepathext.SmartJoin(r.Executor.Dir, "file.txt"))
assert.Error(t, err, "file.txt should not exist in dry mode")
}),
)
}
func TestDryChecksum(t *testing.T) {
t.Parallel()
const dir = "testdata/dry_checksum"
checksumFile := filepathext.SmartJoin(dir, ".task/checksum/default")
_ = os.Remove(checksumFile)
NewExecutorTest(t,
WithName("dry"),
WithExecutorOptions(
task.WithDir(dir),
task.WithDry(true),
),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
_, err := os.Stat(checksumFile)
require.Error(t, err, "checksum file should not exist")
}),
)
NewExecutorTest(t,
WithName("not dry"),
WithExecutorOptions(task.WithDir(dir)),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
_, err := os.Stat(checksumFile)
require.NoError(t, err, "checksum file should exist")
}),
)
}
// fixedSourceModTime pins a source file's modification time so that
// timestamp-fingerprinting output (which reads that mtime) is deterministic
// across machines and test runs, and can be golden-fixture compared.
var fixedSourceModTime = time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
func TestStatusVariables(t *testing.T) {
t.Parallel()
const dir = "testdata/status_vars"
_ = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))
_ = os.Remove(filepathext.SmartJoin(dir, "generated.txt"))
NewExecutorTest(t,
WithName("build-checksum"),
WithExecutorOptions(
task.WithDir(dir),
task.WithVerbose(true),
),
WithTask("build-checksum"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Contains(t, r.Output, "3e464c4b03f4b65d740e1e130d4d108a")
}),
)
sourceFile := filepathext.SmartJoin(dir, "source.txt")
require.NoError(t, os.Chtimes(sourceFile, fixedSourceModTime, fixedSourceModTime))
NewExecutorTest(t,
WithName("build-ts"),
WithExecutorOptions(
task.WithDir(dir),
task.WithVerbose(true),
),
WithTask("build-ts"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
inf, err := os.Stat(sourceFile)
require.NoError(t, err)
assert.Contains(t, r.Output, fmt.Sprintf("%d", inf.ModTime().Unix()))
assert.Contains(t, r.Output, inf.ModTime().String())
}),
)
}
func TestCmdsVariables(t *testing.T) {
t.Parallel()
const dir = "testdata/cmds_vars"
_ = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))
NewExecutorTest(t,
WithName("build-checksum"),
WithExecutorOptions(
task.WithDir(dir),
task.WithVerbose(true),
),
WithTask("build-checksum"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Contains(t, r.Output, "3e464c4b03f4b65d740e1e130d4d108a")
}),
)
sourceFile := filepathext.SmartJoin(dir, "source.txt")
require.NoError(t, os.Chtimes(sourceFile, fixedSourceModTime, fixedSourceModTime))
NewExecutorTest(t,
WithName("build-ts"),
WithExecutorOptions(
task.WithDir(dir),
task.WithVerbose(true),
),
WithTask("build-ts"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
inf, err := os.Stat(sourceFile)
require.NoError(t, err)
assert.Contains(t, r.Output, fmt.Sprintf("%d", inf.ModTime().Unix()))
assert.Contains(t, r.Output, inf.ModTime().String())
}),
)
}
func TestFingerprintVarMethod(t *testing.T) {
t.Parallel()
tests := []struct {
name string
dir string
executorOpts []task.ExecutorOption
wantErr bool
pinSourceModTime bool
assertOutput func(t *testing.T, output string)
}{
{
name: "TIMESTAMP is injected when the method is inherited from the Taskfile",
dir: "testdata/method_taskfile_timestamp",
// The output embeds the source file's modification time; pin it
// so the value is deterministic across machines and test runs.
pinSourceModTime: true,
assertOutput: func(t *testing.T, output string) {
t.Helper()
// An unresolved variable renders as an empty string, so this
// has to match an actual timestamp, not just the prefix.
assert.Regexp(t, `ts=\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}`, output)
},
},
{
name: "no variable is injected when the effective method is none",
dir: "testdata/method_taskfile_none",
assertOutput: func(t *testing.T, output string) {
t.Helper()
assert.Contains(t, output, "cs=\n")
},
},
{
name: "an invalid method doesn't fail a run that skips fingerprinting",
dir: "testdata/method_invalid",
executorOpts: []task.ExecutorOption{task.WithForce(true)},
assertOutput: func(t *testing.T, output string) {
t.Helper()
assert.Contains(t, output, "cs=[]\n")
},
},
{
name: "an invalid method is still reported by the up-to-date check",
dir: "testdata/method_invalid",
wantErr: true,
},
}
for _, tt := range tests {
_ = os.RemoveAll(filepathext.SmartJoin(tt.dir, ".task"))
if tt.pinSourceModTime {
sourceFile := filepathext.SmartJoin(tt.dir, "source.txt")
require.NoError(t, os.Chtimes(sourceFile, fixedSourceModTime, fixedSourceModTime))
}
opts := []ExecutorTestOption{
WithName(tt.name),
WithExecutorOptions(append([]task.ExecutorOption{task.WithDir(tt.dir)}, tt.executorOpts...)...),
WithTask("build"),
}
if tt.wantErr {
opts = append(opts, WithRunError())
} else {
opts = append(opts, WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
tt.assertOutput(t, r.Output)
}))
}
NewExecutorTest(t, opts...)
}
}
func TestErrorCode(t *testing.T) {
t.Parallel()
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 {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(
task.WithDir("testdata/error_code"),
task.WithSilent(true),
),
WithTask(test.task),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
var taskRunErr *errors.TaskRunError
require.ErrorAs(t, r.Err, &taskRunErr)
assert.Equal(t, test.expected, taskRunErr.TaskExitCode(), "unexpected exit code from task")
}),
)
}
}
func TestRunOnceJoinerHonorsItsOwnTimeout(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/run_once_timeout")),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
// The joiner used to wait on the shared execution alone, ignoring
// its own timeout for as long as that execution took.
assert.Less(t, r.Duration, 5*time.Second)
var timeoutErr *errors.TaskTimeoutError
require.ErrorAs(t, r.Err, &timeoutErr)
assert.Equal(t, "joiner", timeoutErr.TaskName)
assert.NotContains(t, r.Output, "should not be reached")
}),
)
}
func TestDeferredTaskTimeout(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/deferred"),
task.WithVerbose(true),
),
WithTask("parent-with-timeout"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Less(t, r.Duration, 500*time.Millisecond)
assert.Contains(t, r.Output, "parent completed")
assert.NotContains(t, r.Output, "\ncleanup completed\n")
assert.Contains(t, r.Output, "ignored error in deferred cmd")
}),
)
}
func TestExitCodeTimeout(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/exit_code")),
WithTask("exit-timeout"),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
var runErr *errors.TaskRunError
require.ErrorAs(t, r.Err, &runErr)
assert.Equal(t, errors.TimeoutExitCode, runErr.TaskExitCode())
}),
)
}
func TestDepTimeout(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithName("timeout exceeded"),
WithExecutorOptions(task.WithDir("testdata/dep_timeout")),
WithTask("timeout-exceeded"),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Less(t, r.Duration, 5*time.Second)
var timeoutErr *errors.TaskTimeoutError
require.ErrorAs(t, r.Err, &timeoutErr)
assert.Equal(t, "slow", timeoutErr.TaskName)
assert.NotContains(t, r.Output, "should not be reached")
}),
)
NewExecutorTest(t,
WithName("timeout not exceeded"),
WithExecutorOptions(task.WithDir("testdata/dep_timeout")),
WithTask("timeout-not-exceeded"),
)
}
func TestCommandTimeoutBoundsIfCondition(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/timeout")),
WithTask("slow-if-condition"),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Less(t, r.Duration, 5*time.Second)
var timeoutErr *errors.TaskTimeoutError
require.ErrorAs(t, r.Err, &timeoutErr)
// A condition that times out fails the command, it does not skip it.
assert.NotContains(t, r.Output, "condition was met")
}),
)
}
func TestCommandTimeoutAttribution(t *testing.T) {
t.Parallel()
tests := []struct {
name string
task string
notContains string
}{
{
name: "a command declaring no timeout is not blamed for one",
task: "inherited-timeout",
notContains: "(0s)",
},
{
name: "a command is not blamed for a timeout it never reached",
task: "larger-child-timeout",
notContains: "10m",
},
}
for _, test := range tests {
NewExecutorTest(t,
WithName(test.name),
WithExecutorOptions(task.WithDir("testdata/timeout")),
WithTask(test.task),
WithRunError(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
assert.Contains(t, r.Err.Error(), "command timeout exceeded (500ms)")
assert.NotContains(t, r.Err.Error(), test.notContains)
var timeoutErr *errors.TaskTimeoutError
require.ErrorAs(t, r.Err, &timeoutErr)
assert.Equal(t, test.task, timeoutErr.TaskName)
// --watch swallows context errors; a timeout must not look like one.
assert.False(t, errors.Is(r.Err, context.DeadlineExceeded))
}),
)
}
}
func TestUserWorkingDirectoryWithIncluded(t *testing.T) {
t.Parallel()
wd, err := os.Getwd()
require.NoError(t, err)
wd = filepath.ToSlash(filepathext.SmartJoin(wd, "testdata/user_working_dir_with_includes/somedir"))
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/user_working_dir_with_includes"),
task.WithUserWorkingDir(wd),
),
WithTask("included:echo"),
WithFixtureTemplating(),
)
}
func TestIncludeWithVarsInInclude(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/include_with_vars_inside_include")),
WithNoRun(),
)
}
func TestGitignoreTaskListFallback(t *testing.T) { //nolint:paralleltest // shares testdata/gitignore with TestGitignoreChecksum
NewExecutorTest(t,
WithExecutorOptions(task.WithDir("testdata/gitignore")),
WithNoRun(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
listed, err := r.Executor.CompiledTaskForTaskList(&task.Call{Task: "build"})
require.NoError(t, err)
assert.True(t, listed.ShouldUseGitignore(),
"task list should reflect the global use_gitignore fallback")
listedOff, err := r.Executor.CompiledTaskForTaskList(&task.Call{Task: "build-no-use_gitignore"})
require.NoError(t, err)
assert.False(t, listedOff.ShouldUseGitignore(),
"explicit use_gitignore: false must be preserved in the list path")
}),
)
}
func TestSummary(t *testing.T) {
t.Parallel()
NewExecutorTest(t,
WithExecutorOptions(
task.WithDir("testdata/summary"),
task.WithSummary(true),
task.WithSilent(true),
),
WithTasks("task-with-summary", "other-task-with-summary"),
)
}
func TestSilence(t *testing.T) {
t.Parallel()
tests := []string{
"silent",
"chatty",
"task-test-silent-calls-chatty-non-silenced",
"task-test-silent-calls-chatty-silenced",
"task-test-chatty-calls-chatty-non-silenced",
"task-test-chatty-calls-chatty-silenced",
"task-test-no-cmds-calls-chatty-silenced",
"task-test-chatty-calls-silenced-cmd",
"task-test-is-silent-depends-on-chatty-non-silenced",
"task-test-is-silent-depends-on-chatty-silenced",
"task-test-is-chatty-depends-on-chatty-silenced",
}
for i, taskName := range tests {
opts := []ExecutorTestOption{
WithName(taskName),
WithExecutorOptions(task.WithDir("testdata/silent")),
WithTask(taskName),
}
if i == 0 {
// Verify that the silent flag is in place before running anything.
opts = append(opts, WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
fetchedTask, err := r.Executor.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")
}))
}
NewExecutorTest(t, opts...)
}
}
func TestGenerates(t *testing.T) {
t.Parallel()
const dir = "testdata/generates"
const srcTask = "sub/src.txt"
srcFile := filepathext.SmartJoin(dir, srcTask)
destTasks := []string{"rel.txt", "abs.txt", "my text file.txt"}
for _, f := range append([]string{srcTask}, destTasks...) {
_ = os.Remove(filepathext.SmartJoin(dir, f))
}
for _, destTask := range destTasks {
destFile := filepathext.SmartJoin(dir, destTask)
NewExecutorTest(t,
WithName(destTask+" (first run)"),
WithExecutorOptions(task.WithDir(dir)),
WithTask(destTask),
WithFixtureTemplating(),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
_, err := os.Stat(srcFile)
assert.NoError(t, err, "File should exist")
_, err = os.Stat(destFile)
assert.NoError(t, err, "File should exist")
}),
)
NewExecutorTest(t,
WithName(destTask+" (up to date)"),
WithExecutorOptions(task.WithDir(dir)),
WithTask(destTask),
)
}
}
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
for _, f := range test.files {
_ = os.Remove(filepathext.SmartJoin(dir, f))
}
checksumFile := filepathext.SmartJoin(dir, test.files[1])
var capturedTime time.Time
NewExecutorTest(t,
WithName(test.task+" (first run)"),
WithExecutorOptions(task.WithDir(dir)),
WithTask(test.task),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
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(checksumFile)
require.NoError(t, err)
capturedTime = s.ModTime()
}),
)
NewExecutorTest(t,
WithName(test.task+" (up to date)"),
WithExecutorOptions(task.WithDir(dir)),
WithTask(test.task),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
s, err := os.Stat(checksumFile)
require.NoError(t, err)
assert.Equal(t, capturedTime, s.ModTime())
}),
)
}
}
// TestStatusTimestamp is a regression test for https://github.com/go-task/task/issues/1230.
// When using method: timestamp, deleting a generated file should cause the task to re-run,
// not be skipped because the timestamp file is still present.
func TestStatusTimestamp(t *testing.T) { // nolint:paralleltest // cannot run in parallel
const dir = "testdata/timestamp"
generatedFile := filepathext.SmartJoin(dir, "generated.txt")
_ = os.Remove(generatedFile)
_ = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))
NewExecutorTest(t,
WithName("first run"),
WithExecutorOptions(task.WithDir(dir)),
WithTask("build"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
_, err := os.Stat(generatedFile)
require.NoError(t, err, "generated.txt should exist after first run")
}),
)
NewExecutorTest(t,
WithName("up to date"),
WithExecutorOptions(task.WithDir(dir)),
WithTask("build"),
)
// Delete the generated file (simulate a clean), but leave the timestamp file.
require.NoError(t, os.Remove(generatedFile))
NewExecutorTest(t,
WithName("re-run after generated file removed"),
WithExecutorOptions(task.WithDir(dir)),
WithTask("build"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
// This is the regression: previously the task was incorrectly
// skipped because the timestamp file was still present.
assert.NotContains(t, r.Output, "is up to date", "task should re-run when generated file is missing")
_, err := os.Stat(generatedFile)
require.NoError(t, err, "generated.txt should be recreated after third run")
}),
)
}
// TestStatusChecksumMissingGenerated is a regression test for https://github.com/go-task/task/issues/1230.
// When using method: checksum, deleting a generated file should cause the task to re-run,
// not be skipped because the checksum file still matches.
func TestStatusChecksumMissingGenerated(t *testing.T) { // nolint:paralleltest // cannot run in parallel
const dir = "testdata/checksum"
generatedFile := filepathext.SmartJoin(dir, "generated.txt")
_ = os.Remove(generatedFile)
_ = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))
NewExecutorTest(t,
WithName("first run"),
WithExecutorOptions(task.WithDir(dir)),
WithTask("build"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
_, err := os.Stat(generatedFile)
require.NoError(t, err, "generated.txt should exist after first run")
}),
)
NewExecutorTest(t,
WithName("up to date"),
WithExecutorOptions(task.WithDir(dir)),
WithTask("build"),
)
// Delete the generated file (simulate a clean), but leave the checksum file.
require.NoError(t, os.Remove(generatedFile))
NewExecutorTest(t,
WithName("re-run after generated file removed"),
WithExecutorOptions(task.WithDir(dir)),
WithTask("build"),
WithAssert(func(t *testing.T, r *ExecutorTestResult) {
t.Helper()
// This is the regression: previously the task was incorrectly
// skipped because the checksum file still matched.
assert.NotContains(t, r.Output, "is up to date", "task should re-run when generated file is missing")
_, err := os.Stat(generatedFile)
require.NoError(t, err, "generated.txt should be recreated after third run")
}),
)
}