command_linux_test.go

package cmd

import (
	"bytes"
	"context"
	"os"
	"os/exec"
	"strings"
	"syscall"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestCommand_ExecuteStderr(t *testing.T) {
	cmd := NewCommand(">&2 echo hello")

	err := cmd.Execute()

	assert.Nil(t, err)
	assert.Equal(t, "hello\n", cmd.Stderr())
}

func TestCommand_WithTimeout(t *testing.T) {
	cmd := NewCommand("sleep 0.1;", WithTimeout(1*time.Millisecond))

	err := cmd.Execute()
	assert.NotNil(t, err)
	// Sadly a process can not be killed every time :(
	containsMsg := strings.Contains(err.Error(), "timeout occurred and can not kill process with pid") || strings.Contains(err.Error(), "command timed out after 1ms")
	assert.True(t, containsMsg)
}

func TestCommand_WithValidTimeout(t *testing.T) {
	cmd := NewCommand("sleep 0.01;", WithTimeout(500*time.Millisecond))

	err := cmd.Execute()

	assert.Nil(t, err)
}

func TestCommand_WithWorkingDir(t *testing.T) {
	setWorkingDir := func(c *Command) {
		c.WorkingDir = "/tmp"
	}

	cmd := NewCommand("pwd", setWorkingDir)
	cmd.Execute()

	assert.Equal(t, "/tmp\n", cmd.Stdout())
}

func TestCommand_WithStandardStreams(t *testing.T) {
	tmpFile, err := os.CreateTemp("/tmp", "stdout_")
	require.NoError(t, err)
	originalStdout := os.Stdout
	os.Stdout = tmpFile

	// Reset os.Stdout to its original value
	defer func() {
		os.Stdout = originalStdout
	}()

	cmd := NewCommand("echo hey", WithStandardStreams)
	cmd.Execute()

	r, err := os.ReadFile(tmpFile.Name())
	require.NoError(t, err)
	assert.Equal(t, "hey\n", string(r))
}

func TestCommand_WithoutTimeout(t *testing.T) {
	cmd := NewCommand("sleep 0.001; echo hello", WithoutTimeout)

	err := cmd.Execute()

	assert.Nil(t, err)
	assert.Equal(t, "hello\n", cmd.Stdout())
}

func TestCommand_WithInvalidDir(t *testing.T) {
	cmd := NewCommand("echo hello", WithWorkingDir("/invalid"))
	err := cmd.Execute()
	assert.NotNil(t, err)
	assert.Equal(t, "chdir /invalid: no such file or directory", err.Error())
}

func TestWithInheritedEnvironment(t *testing.T) {
	os.Setenv("FROM_OS", "is on os")
	os.Setenv("OVERWRITE", "is on os but should be overwritten")
	defer func() {
		os.Unsetenv("FROM_OS")
		os.Unsetenv("OVERWRITE")
	}()

	c := NewCommand(
		"echo $FROM_OS $OVERWRITE",
		WithInheritedEnvironment(map[string]string{"OVERWRITE": "overwritten"}))
	c.Execute()

	assertEqualWithLineBreak(t, "is on os overwritten", c.Stdout())
}

func TestWithCustomStderr(t *testing.T) {
	writer := bytes.Buffer{}
	c := NewCommand(">&2 echo stderr; sleep 0.01; echo stdout;", WithCustomStderr(&writer))
	c.Execute()

	assertEqualWithLineBreak(t, "stderr", writer.String())
	assertEqualWithLineBreak(t, "stdout", c.Stdout())
	assertEqualWithLineBreak(t, "stderr", c.Stderr())
	assertEqualWithLineBreak(t, "stderr\nstdout", c.Combined())
}

func TestWithCustomStdout(t *testing.T) {
	writer := bytes.Buffer{}
	c := NewCommand(">&2 echo stderr; sleep 0.01; echo stdout;", WithCustomStdout(&writer))
	c.Execute()

	assertEqualWithLineBreak(t, "stdout", writer.String())
	assertEqualWithLineBreak(t, "stdout", c.Stdout())
	assertEqualWithLineBreak(t, "stderr", c.Stderr())
	assertEqualWithLineBreak(t, "stderr\nstdout", c.Combined())
}

func TestWithEnvironmentVariables(t *testing.T) {
	c := NewCommand("echo $env", WithEnvironmentVariables(map[string]string{"env": "value"}))
	c.Execute()

	assertEqualWithLineBreak(t, "value", c.Stdout())
}

func TestCommand_WithContext(t *testing.T) {
	// ensure legacy timeout is honored
	cmd := NewCommand("sleep 3;", WithTimeout(1*time.Second))
	err := cmd.Execute()
	assert.NotNil(t, err)
	assert.Equal(t, "command timed out after 1s", err.Error())

	// set context timeout to 2 seconds to ensure
	// context takes precedence over timeout
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	cmd = NewCommand("sleep 3;", WithTimeout(1*time.Second))
	err = cmd.ExecuteContext(ctx)
	assert.NotNil(t, err)
	assert.Equal(t, "context deadline exceeded", err.Error())
}

func TestCommand_WithCustomBaseCommand(t *testing.T) {
	cmd := NewCommand(
		"echo $0",
		WithCustomBaseCommand(exec.Command("/bin/bash", "-c")),
	)

	err := cmd.Execute()
	assert.Nil(t, err)
	// on darwin we use /bin/sh by default test if we're using bash
	assert.NotEqual(t, "/bin/sh\n", cmd.Stdout())
	assert.Equal(t, "/bin/bash\n", cmd.Stdout())
}

func TestCommand_WithUser(t *testing.T) {
	cred := syscall.Credential{}
	cmd := NewCommand("echo hello", WithUser(cred))
	err := cmd.Execute()
	assert.Error(t, err)
}