Dir string

Entrypoint string

Target string

TrimSpace bool

Files map[string]string

for f := range fct.Files {

_ = os.Remove(filepathext.SmartJoin(fct.Dir, f))

}

e := &task.Executor{

Dir: fct.Dir,

TempDir: filepathext.SmartJoin(fct.Dir, ".task"),

Entrypoint: fct.Entrypoint,

Stdout: io.Discard,

Stderr: io.Discard,

}

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

require.NoError(t, e.Run(context.Background(), &ast.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(fct.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)

})

}

e := &task.Executor{

Dir: "testdata/empty_task",

Stdout: io.Discard,

Stderr: io.Discard,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "default"}))

tt := fileContentTest{

Dir: "testdata/env",

Target: "default",

TrimSpace: false,

Files: map[string]string{

"local.txt": "GOOS='linux' GOARCH='amd64' CGO_ENABLED='0'\n",

"global.txt": "FOO='foo' BAR='overriden' BAZ='baz'\n",

},

}

tt.Run(t)

tt := fileContentTest{

Dir: "testdata/vars",

Target: "default",

Files: map[string]string{

"missing-var.txt": "\n",

"var-order.txt": "ABCDEF\n",

"dependent-sh.txt": "123456\n",

"with-call.txt": "Hi, ABC123!\n",

"from-dot-env.txt": "From .env file\n",

},

}

tt.Run(t)

const dir = "testdata/special_vars"

toAbs := func(rel string) string {

abs, err := filepath.Abs(rel)

assert.NoError(t, err)

return abs

}

tests := []struct {

target string

expected string

}{

// Root

{target: "print-task", expected: "print-task"},

{target: "print-root-dir", expected: toAbs(dir)},

{target: "print-taskfile-dir", expected: toAbs(dir)},

{target: "print-task-version", expected: "unknown"},

// Included

{target: "included:print-task", expected: "included:print-task"},

{target: "included:print-root-dir", expected: toAbs(dir)},

{target: "included:print-taskfile-dir", expected: toAbs(dir) + "/included"},

{target: "included:print-task-version", expected: "unknown"},

}

for _, test := range tests {

t.Run(test.target, func(t *testing.T) {

var buff bytes.Buffer

e := &task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

Silent: true,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: test.target}))

assert.Equal(t, test.expected+"\n", buff.String())

})

}

const (

dir = "testdata/concurrency"

target = "default"

)

e := &task.Executor{

Dir: dir,

Stdout: io.Discard,

Stderr: io.Discard,

Concurrency: 1,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: target}), "e.Run(target)")

tt := fileContentTest{

Dir: "testdata/params",

Target: "default",

TrimSpace: false,

Files: map[string]string{

"hello.txt": "Hello\n",

"world.txt": "World\n",

"exclamation.txt": "!\n",

"dep1.txt": "Dependence1\n",

"dep2.txt": "Dependence2\n",

"spanish.txt": "¡Holla mundo!\n",

"spanish-dep.txt": "¡Holla dependencia!\n",

"portuguese.txt": "Olá, mundo!\n",

"portuguese2.txt": "Olá, mundo!\n",

"german.txt": "Welt!\n",

},

}

tt.Run(t)

const dir = "testdata/deps"

files := []string{

"d1.txt",

"d2.txt",

"d3.txt",

"d11.txt",

"d12.txt",

"d13.txt",

"d21.txt",

"d22.txt",

"d23.txt",

"d31.txt",

"d32.txt",

"d33.txt",

}

for _, f := range files {

_ = os.Remove(filepathext.SmartJoin(dir, f))

}

e := &task.Executor{

Dir: dir,

Stdout: io.Discard,

Stderr: io.Discard,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "default"}))

for _, f := range files {

f = filepathext.SmartJoin(dir, f)

if _, err := os.Stat(f); err != nil {

t.Errorf("File %s should exist", f)

}

}

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)

}

}

var buff bytes.Buffer

e := &task.Executor{

Dir: dir,

TempDir: filepathext.SmartJoin(dir, ".task"),

Stdout: &buff,

Stderr: &buff,

Silent: true,

}

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

// gen-foo creates foo.txt, and will always fail it's status check.

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "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.

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-bar"}))

// gen-silent-baz is marked as being silent, and should only produce output

// if e.Verbose is set to true.

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-bar"}))

// Run gen-bar a third time, to make sure we've triggered the status check.

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-bar"}))

// We're silent, so no output should have been produced.

assert.Empty(t, buff.String())

// 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)

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-bar"}))

buff.Reset()

// Global silence switched of, so we should see output unless the task itself

// is silent.

e.Silent = false

// all: not up-to-date

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-foo"}))

assert.Equal(t, "task: [gen-foo] touch foo.txt", strings.TrimSpace(buff.String()))

buff.Reset()

// status: not up-to-date

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-foo"}))

assert.Equal(t, "task: [gen-foo] touch foo.txt", strings.TrimSpace(buff.String()))

buff.Reset()

// sources: not up-to-date

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-bar"}))

assert.Equal(t, "task: [gen-bar] touch bar.txt", strings.TrimSpace(buff.String()))

buff.Reset()

// all: up-to-date

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-bar"}))

assert.Equal(t, `task: Task "gen-bar" is up to date`, strings.TrimSpace(buff.String()))

buff.Reset()

// sources: not up-to-date, no output produced.

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-silent-baz"}))

assert.Empty(t, buff.String())

// up-to-date, no output produced

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-silent-baz"}))

assert.Empty(t, buff.String())

e.Verbose = true

// up-to-date, output produced due to Verbose mode.

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "gen-silent-baz"}))

assert.Equal(t, `task: Task "gen-silent-baz" is up to date`, strings.TrimSpace(buff.String()))

buff.Reset()

const dir = "testdata/precondition"

var buff bytes.Buffer

e := &task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

// A precondition that has been met

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "foo"}))

if buff.String() != "" {

t.Errorf("Got Output when none was expected: %s", buff.String())

}

// A precondition that was not met

require.Error(t, e.Run(context.Background(), &ast.Call{Task: "impossible"}))

if buff.String() != "task: 1 != 0 obviously!\n" {

t.Errorf("Wrong output message: %s", buff.String())

}

buff.Reset()

// Calling a task with a precondition in a dependency fails the task

require.Error(t, e.Run(context.Background(), &ast.Call{Task: "depends_on_impossible"}))

if buff.String() != "task: 1 != 0 obviously!\n" {

t.Errorf("Wrong output message: %s", buff.String())

}

buff.Reset()

// Calling a task with a precondition in a cmd fails the task

require.Error(t, e.Run(context.Background(), &ast.Call{Task: "executes_failing_task_as_cmd"}))

if buff.String() != "task: 1 != 0 obviously!\n" {

t.Errorf("Wrong output message: %s", buff.String())

}

buff.Reset()

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.Executor{

Dir: dir,

Stdout: buff,

Stderr: 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", srcTask) +

fmt.Sprintf("task: Task \"%s\" is up to date\n", theTask)

// Run task for the first time.

require.NoError(t, e.Run(context.Background(), &ast.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(context.Background(), &ast.Call{Task: theTask}))

if buff.String() != upToDate {

t.Errorf("Wrong output message: %s", buff.String())

}

buff.Reset()

}

const dir = "testdata/checksum"

tests := []struct {

files []string

task string

}{

{[]string{"generated.txt", ".task/checksum/build"}, "build"},

{[]string{"generated.txt", ".task/checksum/build-with-status"}, "build-with-status"},

}

for _, test := range tests {

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 := filepathext.SmartJoin(dir, ".task")

e := task.Executor{

Dir: dir,

TempDir: tempdir,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.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, "checksum/"+test.task))

require.NoError(t, err)

time := s.ModTime()

buff.Reset()

require.NoError(t, e.Run(context.Background(), &ast.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, "checksum/"+test.task))

require.NoError(t, err)

assert.Equal(t, time, s.ModTime())

})

}

const dir = "testdata/alias"

data, err := os.ReadFile(filepathext.SmartJoin(dir, "alias.txt"))

require.NoError(t, err)

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "f"}))

assert.Equal(t, string(data), buff.String())

const dir = "testdata/alias"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

require.Error(t, e.Run(context.Background(), &ast.Call{Task: "x"}))

assert.Equal(t, "", buff.String())

const dir = "testdata/alias"

data, err := os.ReadFile(filepathext.SmartJoin(dir, "alias-summary.txt"))

require.NoError(t, err)

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Summary: true,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "f"}))

assert.Equal(t, string(data), buff.String())

const dir = "testdata/label_uptodate"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "foo"}))

assert.Contains(t, buff.String(), "foobar")

const dir = "testdata/label_summary"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Summary: true,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "foo"}))

assert.Contains(t, buff.String(), "foobar")

const dir = "testdata/label_status"

e := task.Executor{

Dir: dir,

}

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

err := e.Status(context.Background(), &ast.Call{Task: "foo"})

assert.ErrorContains(t, err, "foobar")

const dir = "testdata/label_var"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "foo"}))

assert.Contains(t, buff.String(), "foobaz")

const dir = "testdata/label_summary"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "foo"}))

assert.Contains(t, buff.String(), "foobar")

const dir = "testdata/prompt"

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) {

var inBuff bytes.Buffer

var outBuff bytes.Buffer

var errBuff bytes.Buffer

inBuff.Write([]byte(test.input))

e := task.Executor{

Dir: dir,

Stdin: &inBuff,

Stdout: &outBuff,

Stderr: &errBuff,

AssumeTerm: true,

}

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

err := e.Run(context.Background(), &ast.Call{Task: "foo"})

if test.wantError {

require.Error(t, err)

} else {

require.NoError(t, err)

}

})

}

const dir = "testdata/prompt"

var inBuff bytes.Buffer

var outBuff bytes.Buffer

var errBuff bytes.Buffer

inBuff.Write([]byte("y\n"))

e := task.Executor{

Dir: dir,

Stdin: &inBuff,

Stdout: &outBuff,

Stderr: &errBuff,

AssumeTerm: true,

}

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

err := e.Run(context.Background(), &ast.Call{Task: "bar"})

assert.Contains(t, outBuff.String(), "show-prompt")

require.NoError(t, err)

const dir = "testdata/prompt"

tests := []struct {

name string

assumeYes bool

}{

{"--yes flag should skip prompt", true},

{"task should raise errors.TaskCancelledError", false},

}

for _, test := range tests {

t.Run(test.name, func(t *testing.T) {

var inBuff bytes.Buffer

var outBuff bytes.Buffer

var errBuff bytes.Buffer

// always cancel the prompt so we can require.Error

inBuff.Write([]byte("\n"))

e := task.Executor{

Dir: dir,

Stdin: &inBuff,

Stdout: &outBuff,

Stderr: &errBuff,

AssumeYes: test.assumeYes,

}

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

err := e.Run(context.Background(), &ast.Call{Task: "foo"})

if !test.assumeYes {

require.Error(t, err)

return

}

})

}

const dir = "testdata/label_list"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

if _, err := e.ListTasks(task.ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {

t.Error(err)

}

assert.Contains(t, buff.String(), "foo")

const dir = "testdata/list_mixed_desc"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

var title string

if _, err := e.ListTasks(task.ListOptions{ListAllTasks: true}); err != nil {

t.Error(err)

}

for _, title = range []string{

"foo",

"voo",

"doo",

} {

assert.Contains(t, buff.String(), title)

}

const dir = "testdata/list_mixed_desc"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

if _, err := e.ListTasks(task.ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {

t.Error(err)

}

var title string

assert.Contains(t, buff.String(), "foo")

for _, title = range []string{

"voo",

"doo",

} {

assert.NotContains(t, buff.String(), title)

}

const dir = "testdata/list_desc_interpolation"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

if _, err := e.ListTasks(task.ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {

t.Error(err)

}

assert.Contains(t, buff.String(), "bar")

const dir = "testdata/status_vars"

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

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

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

TempDir: filepathext.SmartJoin(dir, ".task"),

Stdout: &buff,

Stderr: &buff,

Silent: false,

Verbose: true,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "build"}))

assert.Contains(t, buff.String(), "3e464c4b03f4b65d740e1e130d4d108a")

inf, err := os.Stat(filepathext.SmartJoin(dir, "source.txt"))

require.NoError(t, err)

ts := fmt.Sprintf("%d", inf.ModTime().Unix())

tf := inf.ModTime().String()

assert.Contains(t, buff.String(), ts)

assert.Contains(t, buff.String(), tf)

const dir = "testdata/init"

file := filepathext.SmartJoin(dir, "Taskfile.yml")

_ = os.Remove(file)

if _, err := os.Stat(file); err == nil {

t.Errorf("Taskfile.yml should not exist")

}

if err := task.InitTaskfile(io.Discard, dir); err != nil {

t.Error(err)

}

if _, err := os.Stat(file); err != nil {

t.Errorf("Taskfile.yml should exist")

}

_ = os.Remove(file)

const dir = "testdata/cyclic"

e := task.Executor{

Dir: dir,

Stdout: io.Discard,

Stderr: io.Discard,

}

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

assert.IsType(t, &errors.TaskCalledTooManyTimesError{}, e.Run(context.Background(), &ast.Call{Task: "task-1"}))

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) {

e := task.Executor{

Dir: test.Dir,

Stdout: io.Discard,

Stderr: io.Discard,

}

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())

})

}

const dir = "testdata/ignore_errors"

e := task.Executor{

Dir: dir,

Stdout: io.Discard,

Stderr: io.Discard,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "task-should-pass"}))

require.Error(t, e.Run(context.Background(), &ast.Call{Task: "task-should-fail"}))

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "cmd-should-pass"}))

require.Error(t, e.Run(context.Background(), &ast.Call{Task: "cmd-should-fail"}))

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.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "pwd"}))

assert.Equal(t, home, strings.TrimSpace(buff.String()))

const dir = "testdata/dry"

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

_ = os.Remove(file)

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

Dry: true,

}

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

require.NoError(t, e.Run(context.Background(), &ast.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)

}

const dir = "testdata/dry_checksum"

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

_ = os.Remove(checksumFile)

e := task.Executor{

Dir: dir,

TempDir: filepathext.SmartJoin(dir, ".task"),

Stdout: io.Discard,

Stderr: io.Discard,

Dry: true,

}

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

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "default"}))

_, err := os.Stat(checksumFile)

require.Error(t, err, "checksum file should not exist")

e.Dry = false

require.NoError(t, e.Run(context.Background(), &ast.Call{Task: "default"}))

_, err = os.Stat(checksumFile)

require.NoError(t, err, "checksum file should exist")

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",

},

}

tt.Run(t)

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",

},

}

tt.Run(t)

const dir = "testdata/includes_cycle"

var buff bytes.Buffer

e := task.Executor{

Dir: dir,

Stdout: &buff,

Stderr: &buff,

Silent: true,

}

err := e.Setup()

require.Error(t, err)

assert.Contains(t, err.Error(), "task: include cycle detected between")