// CheckList executes a command and optionally tests whether its output does
// or does not contain a given string.
func CheckList(
t *testing.T, params interface{}, cmd, contain string, notflag bool) {
var cmdBuf bytes.Buffer
tmpl := template.Must(template.New("cmd").Parse(cmd))
if err := tmpl.Execute(&cmdBuf, params); err != nil {
t.Fatal(err)
}
cmdString := cmdBuf.String()
fmt.Println(cmdString)
var cmdl *exec.Cmd
if strings.Contains(cmd, "cat") {
cmdl = exec.Command("sh", "-c", cmdString)
} else {
cmdl = exec.Command("sh", "-c", Deis+cmdString)
}
stdout, _, err := utils.RunCommandWithStdoutStderr(cmdl)
if err != nil {
t.Fatal(err)
}
if strings.Contains(stdout.String(), contain) == notflag {
if notflag {
t.Fatalf(
"Didn't expect '%s' in command output:\n%s", contain, stdout)
}
t.Fatalf("Expected '%s' in command output:\n%s", contain, stdout)
}
}
func Execute(t *testing.T, cmd string, params interface{}, failFlag bool, expect string) {
var cmdBuf bytes.Buffer
tmpl := template.Must(template.New("cmd").Parse(cmd))
if err := tmpl.Execute(&cmdBuf, params); err != nil {
t.Fatal(err)
}
cmdString := cmdBuf.String()
fmt.Println(cmdString)
var cmdl *exec.Cmd
if strings.Contains(cmd, "git") {
cmdl = exec.Command("sh", "-c", cmdString)
} else {
cmdl = exec.Command("sh", "-c", Deis+cmdString)
}
switch failFlag {
case true:
if stdout, stderr, err := utils.RunCommandWithStdoutStderr(cmdl); err != nil {
if strings.Contains(stdout.String(), expect) || strings.Contains(stderr.String(), expect) {
fmt.Println("Test Failed Expected behavior")
} else {
t.Fatalf("Failed:\n%v", err)
}
} else {
if strings.Contains(stdout.String(), expect) || strings.Contains(stderr.String(), expect) {
fmt.Println("expected" + expect)
} else {
t.Fatalf("Failed:\n%v", err)
}
}
case false:
if _, _, err := utils.RunCommandWithStdoutStderr(cmdl); err != nil {
t.Fatalf("Failed:\n%v", err)
} else {
fmt.Println("ok")
}
}
}
func buildsListTest(t *testing.T, params *utils.DeisTestConfig) {
cmd := buildsListCmd
var cmdBuf bytes.Buffer
tmpl := template.Must(template.New("cmd").Parse(cmd))
if err := tmpl.Execute(&cmdBuf, params); err != nil {
t.Fatal(err)
}
cmdString := cmdBuf.String()
cmdl := exec.Command("sh", "-c", utils.Deis+cmdString)
stdout, _, err := utils.RunCommandWithStdoutStderr(cmdl)
if err != nil {
t.Fatal(err)
}
ImageID := strings.Split(stdout.String(), "\n")[2]
params.ImageID = strings.Fields(ImageID)[0]
}
func run(cmd string) {
var cmdBuf bytes.Buffer
tmpl := template.Must(template.New("cmd").Parse(cmd))
if err := tmpl.Execute(&cmdBuf, nil); err != nil {
log.Fatal(err)
}
cmdString := cmdBuf.String()
fmt.Println(cmdString)
var cmdl *exec.Cmd
cmdl = exec.Command("sh", "-c", cmdString)
if _, _, err := utils.RunCommandWithStdoutStderr(cmdl); err != nil {
log.Fatal(err)
} else {
fmt.Println("ok")
}
}
func buildsListTest(t *testing.T, params *itutils.DeisTestConfig) {
Deis := "deis "
cmd := itutils.GetCommand("builds", "list")
var cmdBuf bytes.Buffer
tmpl := template.Must(template.New("cmd").Parse(cmd))
if err := tmpl.Execute(&cmdBuf, params); err != nil {
t.Fatal(err)
}
cmdString := cmdBuf.String()
fmt.Println(cmdString)
cmdl := exec.Command("sh", "-c", Deis+cmdString)
if stdout, _, err := utils.RunCommandWithStdoutStderr(cmdl); err != nil {
t.Fatalf("Failed:\n%v", err)
} else {
ImageId := strings.Split(stdout.String(), "\n")[2]
params.ImageId = strings.Fields(ImageId)[0]
}
}
func CheckList(t *testing.T, params interface{}, cmd, contain string, notflag bool) {
var cmdBuf bytes.Buffer
tmpl := template.Must(template.New("cmd").Parse(cmd))
if err := tmpl.Execute(&cmdBuf, params); err != nil {
t.Fatal(err)
}
cmdString := cmdBuf.String()
fmt.Println(cmdString)
var cmdl *exec.Cmd
if strings.Contains(cmd, "cat") {
cmdl = exec.Command("sh", "-c", cmdString)
} else {
cmdl = exec.Command("sh", "-c", Deis+cmdString)
}
if stdout, _, err := utils.RunCommandWithStdoutStderr(cmdl); err == nil {
if strings.Contains(stdout.String(), contain) != notflag {
fmt.Println("Command Executed perfectly")
} else {
t.Fatal(err)
}
} else {
t.Fatal(err)
}
}