func TestMain(m *testing.M) {
flag.Parse()
kiteURL := testutil.GenKiteURL()
sshkeys = kite.New("sshkeys", "0.0.1")
sshkeys.Config.DisableAuthentication = true
sshkeys.Config.Port = kiteURL.Port()
sshkeys.HandleFunc("list", List)
sshkeys.HandleFunc("add", Add)
sshkeys.HandleFunc("delete", Delete)
go sshkeys.Run()
<-sshkeys.ServerReadyNotify()
defer sshkeys.Close()
u, err := user.Current()
if err != nil {
panic(err)
}
remoteKite := kite.New("remote", "0.0.1")
remoteKite.Config.Username = u.Username
remote = remoteKite.NewClient(kiteURL.String())
err = remote.Dial()
if err != nil {
log.Fatalf("err")
}
defer remoteKite.Close()
os.Exit(m.Run())
}
func TestMain(m *testing.M) {
flag.Parse()
// NOTE(rjeczalik): copy testdata/testfile1.txt so after test execution
// the file is not modified.
if err := testutil.FileCopy("testdata/testfile1.txt", testfile1); err != nil {
panic(err)
}
kiteURL := testutil.GenKiteURL()
fs = kite.New("fs", "0.0.1")
fs.Config.DisableAuthentication = true
fs.Config.Port = kiteURL.Port()
fs.HandleFunc("readDirectory", ReadDirectory)
fs.HandleFunc("glob", Glob)
fs.HandleFunc("readFile", ReadFile)
fs.HandleFunc("writeFile", WriteFile)
fs.HandleFunc("uniquePath", UniquePath)
fs.HandleFunc("getInfo", GetInfo)
fs.HandleFunc("setPermissions", SetPermissions)
fs.HandleFunc("remove", Remove)
fs.HandleFunc("rename", Rename)
fs.HandleFunc("createDirectory", CreateDirectory)
fs.HandleFunc("move", Move)
fs.HandleFunc("copy", Copy)
fs.HandleFunc("getDiskInfo", GetDiskInfo)
go fs.Run()
<-fs.ServerReadyNotify()
defer fs.Close()
remoteKite := kite.New("remote", "0.0.1")
remoteKite.Config.Username = "******"
remote = remoteKite.NewClient(kiteURL.String())
err := remote.Dial()
if err != nil {
log.Fatalf("err")
}
defer remoteKite.Close()
remoteKite2 := kite.New("remote2", "0.0.1")
remoteKite2.Config.Username = "******"
remote2 = remoteKite2.NewClient(kiteURL.String())
err = remote2.Dial()
if err != nil {
log.Fatalf("err")
}
defer remoteKite2.Close()
os.Exit(m.Run())
}
func TestMain(m *testing.M) {
flag.Parse()
kiteURL := testutil.GenKiteURL()
d = kite.New("docker", "0.0.1")
d.Config.DisableAuthentication = true
d.Config.Port = kiteURL.Port()
d.Config.Username = "******"
dockerHost := os.Getenv("DOCKER_HOST")
if dockerHost == "" {
dockerHost = "tcp://192.168.59.103:2376" // darwin, boot2docker
}
dockerCertPath := os.Getenv("DOCKER_CERT_PATH")
if dockerCertPath == "" {
panic("please set DOCKER_CERT_PATH")
}
certFile := dockerCertPath + "/cert.pem"
keyFile := dockerCertPath + "/key.pem"
caFile := dockerCertPath + "/ca.pem"
client, _ := dockerclient.NewVersionnedTLSClient(dockerHost, certFile, keyFile, caFile, "1.16")
dock := &Docker{
client: client,
log: d.Log,
}
d.HandleFunc("create", dock.Create)
d.HandleFunc("start", dock.Start)
d.HandleFunc("connect", dock.Connect) // TODO: doesn't work inside our tests, look at it
d.HandleFunc("stop", dock.Stop)
d.HandleFunc("list", dock.List)
d.HandleFunc("remove", dock.RemoveContainer)
go d.Run()
<-d.ServerReadyNotify()
defer d.Close()
remote = d.NewClient(kiteURL.String())
err := remote.Dial()
if err != nil {
log.Fatalf("err")
}
defer remote.Close()
os.Exit(m.Run())
}
func TestTerminal(t *testing.T) {
kiteURL := testutil.GenKiteURL()
screen, err := exec.LookPath("screen")
if err != nil {
t.Fatalf("unable to find screen: %s", err)
}
terminal := kite.New("terminal", "0.0.1")
terminal.Config.DisableConcurrency = true
terminal.Config.DisableAuthentication = true
terminal.Config.Port = kiteURL.Port()
termInstance := New(testLog, screen)
terminal.HandleFunc("connect", termInstance.Connect)
go terminal.Run()
<-terminal.ServerReadyNotify()
defer terminal.Close()
client := kite.New("client", "0.0.1")
client.Config.DisableAuthentication = true
client.Log = testLog
remote := client.NewClient(kiteURL.String())
err = remote.Dial()
if err != nil {
t.Fatal(err)
}
defer remote.Close()
termClient := newTermHandler()
result, err := remote.Tell("connect", struct {
Remote *termHandler
Session string
SizeX, SizeY int
Mode string
}{
Remote: termClient,
SizeX: 80,
SizeY: 24,
Mode: "create",
})
if err != nil {
t.Error(err)
return
}
var term *remoteTerm
err = result.Unmarshal(&term)
if err != nil {
t.Error(err.Error())
return
}
// Two commands are run to make sure that the order of the keys are preserved.
// If not, sometimes inputs are mixed in a way that is non-deterministic.
err = term.Input.Call(`say kite`)
if err != nil {
t.Fatal(err)
}
// time.Sleep(100 * time.Millisecond)
err = term.ControlSequence.Call("\r")
if err != nil {
t.Fatal(err)
}
// time.Sleep(100 * time.Millisecond)
err = term.Input.Call(`python -c "print 123455+1"`)
if err != nil {
t.Fatal(err)
}
// time.Sleep(100 * time.Millisecond)
err = term.ControlSequence.Call("\r")
if err != nil {
t.Fatal(err)
}
fullOutput := ""
for {
select {
case output := <-termClient.output:
// fmt.Printf("Received output from channel: %+v\n", output)
fullOutput += output
if strings.Contains(fullOutput, "123456") { // magic number
return
}
case <-time.After(2 * time.Second):
fmt.Println(fullOutput)
t.Error("Timeout")
return
}
}
}