func TestEnvOperation(t *testing.T) { // Equivalent to os.Setenv("TEST_RUN_ENV", "fubar") /*if runtime.GOOS == "windows" { status:=Call(`set TEST_RUN_ENV=fubar`).Run() assert.Equal(t, "",status.Error()) } else { status:=Call(`bash -c "export TEST_RUN_ENV=fubar"`).Run() assert.Equal(t, nil,status) }*/ os.Setenv("TEST_RUN_ENV", "fubar") Env = makeEnvMap(os.Environ(), true) assert.Equal(t, "fubar", (*Env)["TEST_RUN_ENV"], "set/export env failed") output := bytes.NewBuffer(nil) if runtime.GOOS == "windows" { Call(`FOO=bar BAH=baz cmd /C 'echo %TEST_RUN_ENV% %FOO%'`).Pipe(Stdout, output).Run() } else { Call(`FOO=bar BAH=baz bash -c "echo -n $TEST_RUN_ENV $FOO"`).Pipe(Stdout, output).Run() } assert.Equal(t, "fubar bar", strings.Trim((*output).String(), " ")) os.Unsetenv("TEST_RUN_ENV") /* if runtime.GOOS == "windows" { Call(`set TEST_RUN_ENV=`).Run() } else { Call(`unset TEST_RUN_ENV`).Run() } */ }
func TestIn(t *testing.T) { var output bytes.Buffer old, _ := os.Getwd() if runtime.GOOS == "windows" { Call("foo.cmd").In("test").Pipe(Stdout, &output).Run() } else { Call("bash foo.sh").In("test").Pipe(Stdout, &output).Run() } assert.Equal(t, "FOOBAR", strings.Trim(output.String(), " ")) now, _ := os.Getwd() assert.Equal(t, now, old, "In failed to reset work directory") }
func TestEnvCombination(t *testing.T) { // set to os defaults Env = makeEnvMap(os.Environ(), false) Env = Env.combine([]string{"USER=$USER:$USER:func"}) assert.Equal(t, user+":"+user+":func", (*Env)["USER"], "Should have been overriden by func environment") assert.Equal(t, len(os.Environ()), len(*Env), "Consolidated environment length changed.") Env = Env.combine([]string{"GOSU_NEW_VAR=foo"}) assert.Equal(t, "foo", (*Env)["GOSU_NEW_VAR"], "Should have conslidated Env set") assert.Equal(t, len(os.Environ())+1, len(*Env), "Consolidated environment length should have increased by 1") }
func TestAt(t *testing.T) { var output bytes.Buffer if runtime.GOOS == "windows" { Call("foo.cmd").At("test").Pipe(Stdout, &output).Run() } else { Call("bash foo.sh").At("test").Pipe(Stdout, &output).Run() } assert.Equal(t, "FOOBAR", strings.Trim(output.String(), " ")) }
func TestEnvInterpretation(t *testing.T) { // set back to default Env = makeEnvMap(os.Environ(), false) Env.Set(`USER1=$USER`, `USER2=$USER1`) Env = Env.combine([]string{"USER3=$USER2"}) assert.Equal(t, user, (*Env)["USER1"], "Should have been evaluated") assert.Equal(t, user, (*Env)["USER3"], "Should have been evaluated during consolidation") Env = Env.combine([]string{"PATH=foo::bar::bah"}) assert.Equal(t, "foo"+string(os.PathListSeparator)+"bar"+string(os.PathListSeparator)+"bah", (*Env)["PATH"], "Should have replaced run.PathSeparator") // set back to defaults Env = makeEnvMap(os.Environ(), false) Env.Set(`FOO=foo`, `FAIL=$FOObar:run`, `PASS=${FOO}bar:run`) assert.Equal(t, ":run", (*Env)["FAIL"], "$FOObar should have been interpreted as empty string.") assert.Equal(t, "foobar:run", (*Env)["PASS"], "${FOO}bar should have been interpreted accordingly.") }
func TestPrompt(t *testing.T) { stdin := os.Stdin defer func() { os.Stdin = stdin }() os.Stdin = r w.WriteString("username\n") assert.Equal(t, "username", strings.Trim(Prompt("Please input: "), " ")) }
func TestWithError(t *testing.T) { var output bytes.Buffer var error bytes.Buffer status := Call(` $cat $t/doesnotexist $cat $t/bar `).With("t=test", "cat=cat").Pipe(Stdout, &output).Pipe(Stderr, &error).Run() assert.Error(t, status) assert.Contains(t, "line=1", status.Error()) assert.Contains(t, "exit", status.Error()) assert.Contains(t, "doesnotexist", error.String()) assert.Equal(t, "", output.String()) }
func TestPromotion(t *testing.T) { assert.Equal(t, "", os.Getenv("_foo")) assert.Equal(t, "", os.Getenv("_test_bar")) assert.Equal(t, "", os.Getenv("_test_opts")) Env = makeEnvMap([]string{"_foo", "_test_bar=bah", `_test_opts="a=b,c=d,*="`}, false) for key, _ := range *Env { Env.promote(key) } assert.Equal(t, "", os.Getenv("_foo")) assert.Equal(t, "bah", os.Getenv("_test_bar")) assert.Equal(t, "\"a=b,c=d,*=\"", os.Getenv("_test_opts")) }
func TestShell(t *testing.T) { if runtime.GOOS == "windows" { return } var output bytes.Buffer // use sh as default shell, which doesn't suport `-n` Shell(`echo foobar`).Pipe(Stdout, &output).Run() assert.Equal(t, "foobar\n", output.String(), "Simple bash failed.") output.Reset() Shell(`bash`, `echo -n foobar`).Pipe(Stdout, &output).Run() assert.Equal(t, "foobar", output.String(), "Simple bash failed.") output.Reset() Shell(`bash`, ` echo -n foobar echo -n bahbaz `).Pipe(Stdout, &output).Run() assert.Equal(t, "foobarbahbaz", output.String(), "Multiline bash failed.") output.Reset() Shell(`bash`, ` echo -n \ foobar `).Pipe(Stdout, &output).Run() assert.Equal(t, "foobar", output.String(), "Bash line continuation failed.") output.Reset() Shell(`bash`, ` echo -n "foobar" `).Pipe(Stdout, &output).Run() assert.Equal(t, "foobar", output.String(), "Bash quotes failed.") output.Reset() Shell(`bash`, ` echo -n "fo\"obar" `).Pipe(Stdout, &output).Run() assert.Equal(t, "fo\"obar", output.String(), "Bash quoted command failed.") }
func TestMultiCommand(t *testing.T) { var output bytes.Buffer Call(cat+" test/foo\n"+cat+" test/bar").Pipe(Stdout, &output).Run() assert.Equal(t, "text from foo\nthis is content of bar\n", output.String()) }
func TestChain(t *testing.T) { var output bytes.Buffer Call(`cat test/foo`).Call(`echo hello`).Call(`echo world`).Pipe(Stdout, &output).Run() assert.Equal(t, "text from foo\nhello\nworld\n", output.String()) }
func TestSingleCommand(t *testing.T) { var output bytes.Buffer Call(`cat test/foo`).Pipe(Stdout, &output).Run() assert.Equal(t, "text from foo\n", output.String()) }
func TestEnvInitialization(t *testing.T) { // set to os defaults Env = makeEnvMap(os.Environ(), false) Env.Set("USER=$USER:run") assert.Equal(t, user+":run", (*Env)["USER"], "Environment interpretation failed") }