// AuthPasswd tests whether `deis auth:passwd` updates a user's password.
func AuthPasswd(t *testing.T, params *DeisTestConfig, password string) {
fmt.Println("deis auth:passwd")
child, err := gexpect.Spawn(Deis + " auth:passwd")
if err != nil {
t.Fatalf("command not started\n%v", err)
}
fmt.Println("current password:"******"current password: "******"expect password failed\n%v", err)
}
child.SendLine(params.Password)
fmt.Println("new password:"******"new password: "******"expect password failed\n%v", err)
}
child.SendLine(password)
fmt.Println("new password (confirm):")
err = child.Expect("new password (confirm): ")
if err != nil {
t.Fatalf("expect password failed\n%v", err)
}
child.SendLine(password)
err = child.Expect("Password change succeeded")
if err != nil {
t.Fatalf("command executiuon failed\n%v", err)
}
child.Close()
}
func RemoteExecute(user string, password string, remoteIp string, cmd string) (string, error) {
str := fmt.Sprintf("ssh %s@%s", user, remoteIp)
ssh, err := gexpect.Spawn(str)
if err != nil {
fmt.Println("Spawn", str)
fmt.Println("Could not connect to ", remoteIp, err)
return "", err
}
ssh.Expect("sword")
ssh.SendLine(password)
err = ssh.ExpectTimeout("#", 10*time.Second)
if err != nil {
fmt.Println("Spawn", str)
fmt.Println("password:"******"Login failed to", remoteIp, "(", err, ")", "Please check password")
return "", err
}
ssh.Capture()
ssh.SendLine(cmd)
ssh.Expect("#")
bytes := ssh.Collect()
ssh.SendLine("exit")
ssh.Expect("#")
outStr := fmt.Sprintf("Executed on %s: ", remoteIp) + string(bytes[:])
return outStr, err
}
// AuthCancel tests whether `deis auth:cancel` destroys a user's account.
func AuthCancel(t *testing.T, params *DeisTestConfig) {
fmt.Println("deis auth:cancel")
child, err := gexpect.Spawn(Deis + " auth:cancel")
if err != nil {
t.Fatalf("command not started\n%v", err)
}
fmt.Println("username:"******"username:"******"expect username failed\n%v", err)
}
child.SendLine(params.UserName)
fmt.Print("password:"******"password:"******"expect password failed\n%v", err)
}
child.SendLine(params.Password)
err = child.ExpectRegex("(y/n)")
if err != nil {
t.Fatalf("expect cancel \n%v", err)
}
child.SendLine("y")
err = child.Expect("Account cancelled")
if err != nil {
t.Fatalf("command executiuon failed\n%v", err)
}
child.Close()
}
func main() {
log.Printf("Testing Ping interact... \n")
child, err := gexpect.Spawn("ping -c8 127.0.0.1")
if err != nil {
panic(err)
}
child.Interact()
log.Printf("Success\n")
}
func PlayCmdLine(id string) (success bool) {
success = false
log.Printf("Running stream via youtube-dl and gexpect\n")
log.Printf("Command: \"" + "/bin/sh -c 'youtube-dl -o - " + id + " | ffmpeg -i - -f mp3 pipe:1 | mpg123 - '" + "\"")
child, err := gexpect.Spawn("/bin/sh -c 'youtube-dl -o - " + id + " | ffmpeg -i - -f mp3 pipe:1 | mpg123 - '")
if err != nil {
return false
}
child.Interact()
return
}
func TestUcatListen(t *testing.T) {
child, err := gexpect.Spawn("libutp/ucat-static -l -p 8000")
if err != nil {
t.Fatal(err)
}
time.Sleep(500 * time.Millisecond)
addr, err := utp.ResolveAddr("utp", "127.0.0.1:8000")
if err != nil {
t.Fatal(err)
}
c, err := utp.DialUTPTimeout("utp", nil, addr, 1000*time.Millisecond)
if err != nil {
t.Fatal(err)
}
var payload [128]byte
_, err = rand.Read(payload[:])
if err != nil {
t.Fatal(err)
}
msg := hex.EncodeToString(payload[:])
_, err = c.Write([]byte(msg + "\n"))
if err != nil {
t.Fatal(err)
}
err = child.ExpectTimeout(msg, 1000*time.Millisecond)
if err != nil {
t.Fatal(err)
}
child.SendLine(msg + "\n")
err = c.SetDeadline(time.Now().Add(1000 * time.Millisecond))
if err != nil {
t.Fatal(err)
}
var buf [1024]byte
l, err := c.Read(buf[:])
if err != nil {
t.Fatal(err)
}
if string(buf[:l]) != msg+"\n" {
t.Errorf("expected payload of %s; got %s", msg, string(buf[:l]))
}
c.Close()
child.Wait()
}
// newExpectCmd creates a new Expect command out of the given argument
// strings. We can then interact with the command as per normal expect,
// but one difference is that any failures become fatal on the supplied
// testing.T object.
func (u user) newExpectCmd(t *testing.T, args ...string) *expectCmd {
cmd := []string{
keybaseBinaryPath(),
"--standalone",
"-H",
u.makeHome(t),
}
cmd = append(cmd, args...)
es, err := gexpect.Spawn(strings.Join(cmd, " "))
if err != nil {
t.Fatalf("Error spwaning %v: %v", cmd, err)
}
return &expectCmd{es}
}
func main() {
waitChan := make(chan string)
fmt.Printf("Starting screen.. \n")
child, err := gexpect.Spawn("screen")
if err != nil {
panic(err)
}
sender, reciever := child.AsyncInteractChannels()
go func() {
waitString := ""
count := 0
for {
select {
case waitString = <-waitChan:
count++
case msg, open := <-reciever:
if !open {
return
}
fmt.Printf("Recieved: %s\n", msg)
if strings.Contains(msg, waitString) {
if count >= 1 {
waitChan <- msg
count -= 1
}
}
}
}
}()
wait := func(str string) {
waitChan <- str
<-waitChan
}
fmt.Printf("Waiting until started.. \n")
wait(" ")
fmt.Printf("Sending Enter.. \n")
sender <- "\n"
wait("$")
fmt.Printf("Sending echo.. \n")
sender <- "echo Hello World\n"
wait("Hello World")
fmt.Printf("Received echo. \n")
}
func main() {
fmt.Printf("Starting python.. \n")
child, err := gexpect.Spawn("python")
if err != nil {
panic(err)
}
fmt.Printf("Expecting >>>.. \n")
child.Expect(">>>")
fmt.Printf("print 'Hello World'..\n")
child.SendLine("print 'Hello World'")
child.Expect(">>>")
fmt.Printf("Interacting.. \n")
child.Interact()
fmt.Printf("Done \n")
child.Close()
}
func main() {
log.Printf("Testing Ftp... ")
child, err := gexpect.Spawn("ftp ftp.openbsd.org")
if err != nil {
panic(err)
}
child.Expect("Name")
child.SendLine("anonymous")
child.Expect("Password")
child.SendLine("*****@*****.**")
child.Expect("ftp> ")
child.SendLine("cd /pub/OpenBSD/3.7/packages/i386")
child.Expect("ftp> ")
child.SendLine("bin")
child.Expect("ftp> ")
child.SendLine("prompt")
child.Expect("ftp> ")
child.SendLine("pwd")
child.Expect("ftp> ")
log.Printf("Success\n")
}