package executor

import (
	"bytes"
	"fmt"
	"os/exec"
	"strings"
	"testing"
)

var closeSELinux = []string{
	"sed",
	"-i",
	"s/SELINUX=enforcing/SELINUX=disabled/g",
	"/etc/selinux/config",
}

var callShellScript = []string{
	"/bin/bash",
	"/root/IdeaProjects/ProjectOctopus/agent-go/tmp/simple.sh",
}

var shutdownFirewalld = []string{
	// wrong usage of &&
	"systemctl", "stop", "firewalld", "&&", "systemctl", "disable", "firewalld",
}

var pipelineCommandFalse = []string{
	"ls",
	"/etc",
	"|",
	"grep",
	"passwd",
}

var pipelineCommand = [][]string{
	{
		"cat",
		"/home/wdd/IdeaProjects/ProjectOctopus/agent-go/executor/script/123",
	},
	{
		"grep",
		"passwd",
	},
}

var pipelineCommandMore = "apt-cache madison docker-ce | awk {print$3} | cut -d: -f2"
var pipelineCommandThird = "ls /etc/ | grep passwd | head -2"
var pipelineCommandSecond = "systemctl status docker.service | grep active | wc -w"

var ifconfigCommand = []string{"ifconfig"}

func TestReadTimeOutput(t *testing.T) {

	ReadTimeCommandExecutor(ifconfigCommand)

}

func TestAllCommandExecutor(t *testing.T) {
	ok, result := AllCommandExecutor(pipelineCommandFalse)

	t.Logf("执行结果为 => %#v", ok)
	t.Logf("执行日志为 => %#v", result)

}

func TestPureResultSingleExecute(t *testing.T) {

	PureResultSingleExecute(closeSELinux)

}

func TestPipelineCommandExecutorSingle(t *testing.T) {

	cmd1 := exec.Command("ls", "/etc/")
	cmd2 := exec.Command("grep", "passwd")

	var outputBuf1 bytes.Buffer
	cmd1.Stdout = &outputBuf1
	if err := cmd1.Start(); err != nil {
		fmt.Printf("Error: The first command can not be startup %s\n", err)
		return
	}
	if err := cmd1.Wait(); err != nil {
		fmt.Printf("Error: Couldn't wait for the first command: %s\n", err)
		return
	}
	cmd2.Stdin = &outputBuf1
	var outputBuf2 bytes.Buffer
	cmd2.Stdout = &outputBuf2
	if err := cmd2.Start(); err != nil {
		fmt.Printf("Error: The second command can not be startup: %s\n", err)
		return
	}
	if err := cmd2.Wait(); err != nil {
		fmt.Printf("Error: Couldn't wait for the second command: %s\n", err)
		return
	}

	s := outputBuf2.String()
	split := strings.Split(s, "\n")

	BasicPrettyPrint(true, split)

}

func TestPipelineCommandExecutor(t *testing.T) {

	//PipelineCommandExecutor(pipelineCommand)
	pipelineStringToCommand := BasicTransPipelineCommand(pipelineCommandMore)

	t.Logf("pipelineCommmand are => %#v", pipelineStringToCommand)

	ok, resultLog := PipelineCommandExecutor(pipelineStringToCommand)

	t.Logf("command execute ok is => %#v", ok)
	t.Logf("command result are 下 \n")
	BasicPrettyPrint(ok, resultLog)
}