func (s *S) TestServiceInfoRun(c *gocheck.C) {
var stdout, stderr bytes.Buffer
expected := `Info for "mongodb"
Instances
+-----------+-------+-------+--------+
| Instances | Apps | key | key2 |
+-----------+-------+-------+--------+
| mymongo | myapp | value | value2 |
+-----------+-------+-------+--------+
Plans
+-------+--------------+
| Name | Description |
+-------+--------------+
| small | another plan |
+-------+--------------+
`
args := []string{"mongodb"}
context := cmd.Context{
Args: args,
Stdout: &stdout,
Stderr: &stderr,
}
client := cmd.NewClient(&http.Client{Transport: &infoTransport{}}, nil, manager)
err := (&ServiceInfo{}).Run(&context, client)
c.Assert(err, gocheck.IsNil)
obtained := stdout.String()
c.Assert(obtained, gocheck.Equals, expected)
}
func (s *S) TestServiceDocRun(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := `This is a test doc for a test service.
Service test is foo bar.
`
expected := result
ctx := cmd.Context{
Args: []string{"foo"},
Stdout: &stdout,
Stderr: &stderr,
}
transport := testing.ConditionalTransport{
Transport: testing.Transport{
Message: result,
Status: http.StatusOK,
},
CondFunc: func(r *http.Request) bool {
return r.Method == "GET" && r.URL.Path == "/services/foo/doc"
},
}
client := cmd.NewClient(&http.Client{Transport: &transport}, nil, manager)
err := (&ServiceDoc{}).Run(&ctx, client)
c.Assert(err, gocheck.IsNil)
obtained := stdout.String()
c.Assert(obtained, gocheck.Equals, expected)
}
func (s *S) TestUnitRemove(c *gocheck.C) {
var stdout, stderr bytes.Buffer
var called bool
context := cmd.Context{
Args: []string{"2"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: "", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
called = true
b, err := ioutil.ReadAll(req.Body)
c.Assert(err, gocheck.IsNil)
c.Assert(string(b), gocheck.Equals, "2")
return req.URL.Path == "/apps/vapor/units" && req.Method == "DELETE"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := UnitRemove{}
command.Flags().Parse(true, []string{"-a", "vapor"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
expected := "Units successfully removed!\n"
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestUnsetCNameWithoutTheFlag(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
fake := &FakeGuesser{name: "corey"}
trans := &conditionalTransport{
transport{
msg: "Restarted",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
var m map[string]string
err := json.NewDecoder(req.Body).Decode(&m)
c.Assert(err, gocheck.IsNil)
return req.URL.Path == "/apps/corey" &&
req.Method == "POST" &&
m["cname"] == ""
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := (&UnsetCName{GuessingCommand{G: fake}}).Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "cname successfully undefined.\n")
}
func (s *S) TestServiceUnbindWithoutFlag(c *gocheck.C) {
var stdout, stderr bytes.Buffer
var called bool
ctx := cmd.Context{
Args: []string{"hand"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
return req.Method == "DELETE" && req.URL.Path == "/services/instances/hand/sleeve"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
fake := &FakeGuesser{name: "sleeve"}
err := (&ServiceUnbind{GuessingCommand{G: fake}}).Run(&ctx, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "Instance \"hand\" is not bound to the app \"sleeve\" anymore.\n")
}
func (s *S) TestAppInfo(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := `{"Name":"app1","CName":"","Ip":"myapp.tsuru.io","Framework":"php","Repository":"[email protected]:php.git","State":"dead", "Units":[{"Ip":"10.10.10.10","Name":"app1/0","State":"started"}, {"Ip":"9.9.9.9","Name":"app1/1","State":"started"}, {"Ip":"","Name":"app1/2","State":"pending"}],"Teams":["tsuruteam","crane"]}`
expected := `Application: app1
Repository: [email protected]:php.git
Platform: php
Teams: tsuruteam, crane
Address: myapp.tsuru.io
Units:
+--------+---------+
| Unit | State |
+--------+---------+
| app1/0 | started |
| app1/1 | started |
| app1/2 | pending |
+--------+---------+
`
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
client := cmd.NewClient(&http.Client{Transport: &transport{msg: result, status: http.StatusOK}}, nil, manager)
command := AppInfo{}
command.Flags().Parse(true, []string{"--app", "app1"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestAppRestartWithoutTheFlag(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "Restarted",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
return req.URL.Path == "/apps/motorbreath/restart" && req.Method == "GET"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
fake := &FakeGuesser{name: "motorbreath"}
command := AppRestart{GuessingCommand: GuessingCommand{G: fake}}
command.Flags().Parse(true, nil)
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "Restarted")
}
func (s *S) TestAppRun(c *C) {
*AppName = "ble"
var stdout, stderr bytes.Buffer
expected := "http.go http_test.go"
context := cmd.Context{
Args: []string{"ls"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "http.go http_test.go",
status: http.StatusOK,
},
func(req *http.Request) bool {
b := make([]byte, 2)
req.Body.Read(b)
return req.URL.Path == "/apps/ble/run" && string(b) == "ls"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := (&AppRun{}).Run(&context, client)
c.Assert(err, IsNil)
c.Assert(stdout.String(), Equals, expected)
}
func (s *S) TestAppRunShouldUseAllSubsequentArgumentsAsArgumentsToTheGivenCommand(c *C) {
*AppName = "ble"
var stdout, stderr bytes.Buffer
expected := "-rw-r--r-- 1 f staff 119 Apr 26 18:23 http.go"
context := cmd.Context{
Args: []string{"ls", "-l"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "-rw-r--r-- 1 f staff 119 Apr 26 18:23 http.go",
status: http.StatusOK,
},
func(req *http.Request) bool {
b := make([]byte, 5)
req.Body.Read(b)
return req.URL.Path == "/apps/ble/run" && string(b) == "ls -l"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := (&AppRun{}).Run(&context, client)
c.Assert(err, IsNil)
c.Assert(stdout.String(), Equals, expected)
}
func (s *S) TestAppRestart(c *C) {
*AppName = "handful_of_nothing"
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "Restarted",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
return req.URL.Path == "/apps/handful_of_nothing/restart" && req.Method == "GET"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := (&AppRestart{}).Run(&context, client)
c.Assert(err, IsNil)
c.Assert(called, Equals, true)
c.Assert(stdout.String(), Equals, "Restarted")
}
func (s *S) TestAppRunShouldUseAllSubsequentArgumentsAsArgumentsToTheGivenCommand(c *gocheck.C) {
var stdout, stderr bytes.Buffer
expected := "-rw-r--r-- 1 f staff 119 Apr 26 18:23 http.go"
context := cmd.Context{
Args: []string{"ls", "-l"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{
Message: "-rw-r--r-- 1 f staff 119 Apr 26 18:23 http.go",
Status: http.StatusOK,
},
CondFunc: func(req *http.Request) bool {
b := make([]byte, 5)
req.Body.Read(b)
return req.URL.Path == "/apps/ble/run" && string(b) == "ls -l"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := AppRun{}
command.Flags().Parse(true, []string{"--app", "ble"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestAppInfo(c *C) {
*AppName = "app1"
var stdout, stderr bytes.Buffer
result := `{"Name":"app1","Framework":"php","Repository":"[email protected]:php.git","State":"dead", "Units":[{"Ip":"10.10.10.10","Name":"app1/0","State":"started"}, {"Ip":"9.9.9.9","Name":"app1/1","State":"started"}, {"Ip":"","Name":"app1/2","State":"pending"}],"Teams":["tsuruteam","crane"]}`
expected := `Application: app1
State: dead
Repository: [email protected]:php.git
Platform: php
Teams: tsuruteam, crane
Units:
+--------+-------------+---------+
| Unit | Ip | State |
+--------+-------------+---------+
| app1/0 | 10.10.10.10 | started |
| app1/1 | 9.9.9.9 | started |
| app1/2 | | pending |
+--------+-------------+---------+
`
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
client := cmd.NewClient(&http.Client{Transport: &transport{msg: result, status: http.StatusOK}}, nil, manager)
command := AppInfo{}
err := command.Run(&context, client)
c.Assert(err, IsNil)
c.Assert(stdout.String(), Equals, expected)
}
func (s *S) TestServiceRemoveRun(c *gocheck.C) {
var stdout, stderr bytes.Buffer
ctx := cmd.Context{
Args: []string{"some-service-instance"},
Stdout: &stdout,
Stderr: &stderr,
Stdin: strings.NewReader("y\n"),
}
expected := `Are you sure you want to remove service "some-service-instance"? (y/n) `
expected += `Service "some-service-instance" successfully removed!` + "\n"
transport := testing.ConditionalTransport{
Transport: testing.Transport{
Message: "",
Status: http.StatusOK,
},
CondFunc: func(r *http.Request) bool {
return r.URL.Path == "/services/instances/some-service-instance" &&
r.Method == "DELETE"
},
}
client := cmd.NewClient(&http.Client{Transport: &transport}, nil, manager)
err := (&ServiceRemove{}).Run(&ctx, client)
c.Assert(err, gocheck.IsNil)
obtained := stdout.String()
c.Assert(obtained, gocheck.Equals, expected)
}
func (s *S) TestServiceRemoveRun(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Args: []string{"my-service"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := testing.ConditionalTransport{
Transport: testing.Transport{
Message: "",
Status: http.StatusNoContent,
},
CondFunc: func(req *http.Request) bool {
called = true
return req.Method == "DELETE" && req.URL.Path == "/services/my-service"
},
}
client := cmd.NewClient(&http.Client{Transport: &trans}, nil, manager)
err := (&ServiceRemove{}).Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "Service successfully removed.\n")
}
func (s *S) TestEnvUnsetRun(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := "variable(s) successfully unset\n"
context := cmd.Context{
Args: []string{"DATABASE_HOST"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: result, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
want := `["DATABASE_HOST"]` + "\n"
defer req.Body.Close()
got, err := ioutil.ReadAll(req.Body)
c.Assert(err, gocheck.IsNil)
return req.URL.Path == "/apps/someapp/env" && req.Method == "DELETE" && string(got) == want
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := EnvUnset{}
command.Flags().Parse(true, []string{"-a", "someapp"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, result)
}
func (s *S) TestAppRunWithoutTheFlag(c *C) {
var stdout, stderr bytes.Buffer
expected := "-rw-r--r-- 1 f staff 119 Apr 26 18:23 http.go"
context := cmd.Context{
Args: []string{"ls", "-lh"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "-rw-r--r-- 1 f staff 119 Apr 26 18:23 http.go",
status: http.StatusOK,
},
func(req *http.Request) bool {
b := make([]byte, 6)
req.Body.Read(b)
return req.URL.Path == "/apps/bla/run" && string(b) == "ls -lh"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
fake := &FakeGuesser{name: "bla"}
err := (&AppRun{GuessingCommand{G: fake}}).Run(&context, client)
c.Assert(err, IsNil)
c.Assert(stdout.String(), Equals, expected)
}
func (s *S) TestEnvGetRunWithMultipleParams(c *gocheck.C) {
var stdout, stderr bytes.Buffer
jsonResult := `[{"name": "DATABASE_HOST", "value": "somehost", "public": true}, {"name": "DATABASE_USER", "value": "someuser", "public": true}]`
result := "DATABASE_HOST=somehost\nDATABASE_USER=someuser\n"
params := []string{"DATABASE_HOST", "DATABASE_USER"}
context := cmd.Context{
Args: params,
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: jsonResult, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
want := `["DATABASE_HOST","DATABASE_USER"]` + "\n"
defer req.Body.Close()
got, err := ioutil.ReadAll(req.Body)
c.Assert(err, gocheck.IsNil)
return req.URL.Path == "/apps/someapp/env" && req.Method == "GET" && string(got) == want
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := EnvGet{}
command.Flags().Parse(true, []string{"-a", "someapp"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, result)
}
func (s *S) TestTokenGenWithExportOn(c *gocheck.C) {
var stdout, stderr bytes.Buffer
context := cmd.Context{
Args: []string{"myapp"},
Stdout: &stdout,
Stderr: &stderr,
}
manager := cmd.NewManager("glb", "0.2", "ad-ver", &stdout, &stderr, nil, nil)
result := `{"token":"secret123"}`
trans := testing.ConditionalTransport{
Transport: testing.Transport{Message: result, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, gocheck.IsNil)
c.Assert(string(body), gocheck.Equals, `{"client":"myapp","export":true}`)
return req.Method == "POST" && req.URL.Path == "/tokens"
},
}
expected := `Application token: "secret123".` + "\n"
client := cmd.NewClient(&http.Client{Transport: &trans}, nil, manager)
command := tokenGen{}
command.Flags().Parse(true, []string{"-e"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestAppRestart(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "Restarted",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
return req.URL.Path == "/apps/handful_of_nothing/restart" && req.Method == "GET"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := AppRestart{}
command.Flags().Parse(true, []string{"--app", "handful_of_nothing"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "Restarted")
}
func (s *S) TestUnitRemove(c *C) {
*tsuru.AppName = "vapor"
var stdout, stderr bytes.Buffer
var called bool
context := cmd.Context{
Args: []string{"2"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
b, err := ioutil.ReadAll(req.Body)
c.Assert(err, IsNil)
c.Assert(string(b), Equals, "2")
return req.URL.Path == "/apps/vapor/units" && req.Method == "DELETE"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := UnitRemove{}
err := command.Run(&context, client)
c.Assert(err, IsNil)
c.Assert(called, Equals, true)
expected := "Units successfully removed!\n"
c.Assert(stdout.String(), Equals, expected)
}
func (s *S) TestUnsetCName(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "Restarted",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
var m map[string]string
err := json.NewDecoder(req.Body).Decode(&m)
c.Assert(err, gocheck.IsNil)
return req.URL.Path == "/apps/death" &&
req.Method == "POST" &&
m["cname"] == ""
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := UnsetCName{}
command.Flags().Parse(true, []string{"--app", "death"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "cname successfully undefined.\n")
}
func (s *S) TestAppRemoveWithoutArgs(c *gocheck.C) {
var stdout, stderr bytes.Buffer
context := cmd.Context{
Args: nil,
Stdout: &stdout,
Stderr: &stderr,
Stdin: strings.NewReader("y\n"),
}
expected := `Are you sure you want to remove app "secret"? (y/n) App "secret" successfully removed!` + "\n"
trans := &conditionalTransport{
transport{
msg: "",
status: http.StatusOK,
},
func(req *http.Request) bool {
return req.URL.Path == "/apps/secret" && req.Method == "DELETE"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
fake := FakeGuesser{name: "secret"}
guessCommand := tsuru.GuessingCommand{G: &fake}
command := AppRemove{GuessingCommand: guessCommand}
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestServiceUnbind(c *gocheck.C) {
var stdout, stderr bytes.Buffer
var called bool
ctx := cmd.Context{
Args: []string{"hand"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
return req.Method == "DELETE" && req.URL.Path == "/services/instances/hand/pocket"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := ServiceUnbind{}
command.Flags().Parse(true, []string{"-a", "pocket"})
err := command.Run(&ctx, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
c.Assert(stdout.String(), gocheck.Equals, "Instance \"hand\" is not bound to the app \"pocket\" anymore.\n")
}
func (s *S) TestUnitAdd(c *gocheck.C) {
var stdout, stderr bytes.Buffer
var called bool
context := cmd.Context{
Args: []string{"3"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &conditionalTransport{
transport{
msg: "",
status: http.StatusOK,
},
func(req *http.Request) bool {
called = true
b, err := ioutil.ReadAll(req.Body)
c.Assert(err, gocheck.IsNil)
c.Assert(string(b), gocheck.Equals, "3")
return req.URL.Path == "/apps/radio/units" && req.Method == "PUT"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := UnitAdd{}
command.Flags().Parse(true, []string{"-a", "radio"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
expected := "Units successfully added!\n"
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestServiceList(c *gocheck.C) {
var stdout, stderr bytes.Buffer
output := `[{"service": "mysql", "instances": ["mysql01", "mysql02"]}, {"service": "oracle", "instances": []}]`
expectedPrefix := `+---------+------------------+
| Service | Instances |`
lineMysql := "| mysql | mysql01, mysql02 |"
lineOracle := "| oracle | |"
ctx := cmd.Context{
Args: []string{},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: output, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/services/instances"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := (&ServiceList{}).Run(&ctx, client)
c.Assert(err, gocheck.IsNil)
table := stdout.String()
c.Assert(table, gocheck.Matches, "^"+expectedPrefix+".*")
c.Assert(table, gocheck.Matches, "^.*"+lineMysql+".*")
c.Assert(table, gocheck.Matches, "^.*"+lineOracle+".*")
}
func (s *S) TestAppLogWithFollow(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := `[{"Source":"tsuru","Date":"2012-06-20T11:17:22.75-03:00","Message":"creating app lost"},{"Source":"tsuru","Date":"2012-06-20T11:17:22.753-03:00","Message":"app lost successfully created"}]`
expected := cmd.Colorfy("2012-06-20 11:17:22 -0300 [tsuru]:", "blue", "", "") + " creating app lost\n"
expected = expected + cmd.Colorfy("2012-06-20 11:17:22 -0300 [tsuru]:", "blue", "", "") + " app lost successfully created\n"
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
fake := &FakeGuesser{name: "hitthelights"}
command := AppLog{GuessingCommand: GuessingCommand{G: fake}}
command.Flags().Parse(true, []string{"--lines", "12", "-f"})
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: result, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Query().Get("lines") == "12" && req.URL.Query().Get("follow") == "1"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
got := stdout.String()
got = strings.Replace(got, "-0300 -0300", "-0300 BRT", -1)
c.Assert(got, gocheck.Equals, expected)
}
func (s *S) TestServiceBind(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
ctx := cmd.Context{
Args: []string{"my-mysql"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: `["DATABASE_HOST","DATABASE_USER","DATABASE_PASSWORD"]`, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
called = true
return req.Method == "PUT" && req.URL.Path == "/services/instances/my-mysql/g1"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := ServiceBind{}
command.Flags().Parse(true, []string{"-a", "g1"})
err := command.Run(&ctx, client)
c.Assert(err, gocheck.IsNil)
c.Assert(called, gocheck.Equals, true)
expected := `Instance "my-mysql" is now bound to the app "g1".
The following environment variables are now available for use in your app:
- DATABASE_HOST
- DATABASE_USER
- DATABASE_PASSWORD
For more details, please check the documentation for the service, using service-doc command.
`
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestEnvSetValues(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := "variable(s) successfully exported\n"
context := cmd.Context{
Args: []string{
"DATABASE_HOST=some", "host",
"DATABASE_USER=root", "DATABASE_PASSWORD=.1234..abc",
"http_proxy=http://myproxy.com:3128/",
},
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: result, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
want := map[string]string{
"DATABASE_HOST": "some host",
"DATABASE_USER": "******",
"DATABASE_PASSWORD": "******",
"http_proxy": "http://myproxy.com:3128/",
}
defer req.Body.Close()
var got map[string]string
err := json.NewDecoder(req.Body).Decode(&got)
c.Assert(err, gocheck.IsNil)
c.Assert(got, gocheck.DeepEquals, want)
return req.URL.Path == "/apps/someapp/env" && req.Method == "POST"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := EnvSet{}
command.Flags().Parse(true, []string{"-a", "someapp"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
}
func (s *S) TestAppCreate(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := `{"status":"success", "repository_url":"[email protected]:ble.git"}`
expected := `App "ble" is being created!
Use app-info to check the status of the app and its units.
Your repository for "ble" project is "[email protected]:ble.git"` + "\n"
context := cmd.Context{
Args: []string{"ble", "django"},
Stdout: &stdout,
Stderr: &stderr,
}
trans := testing.ConditionalTransport{
Transport: testing.Transport{Message: result, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, gocheck.IsNil)
c.Assert(string(body), gocheck.Equals, `{"name":"ble","platform":"django"}`)
return req.Method == "POST" && req.URL.Path == "/apps"
},
}
client := cmd.NewClient(&http.Client{Transport: &trans}, nil, manager)
command := AppCreate{}
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestAppLog(c *gocheck.C) {
var stdout, stderr bytes.Buffer
t := time.Now()
logs := []log{
{Date: t, Message: "creating app lost", Source: "tsuru"},
{Date: t.Add(2 * time.Hour), Message: "app lost successfully created", Source: "app"},
}
result, err := json.Marshal(logs)
c.Assert(err, gocheck.IsNil)
t = t.In(time.Local)
tfmt := "2006-01-02 15:04:05 -0700"
expected := cmd.Colorfy(t.Format(tfmt)+" [tsuru]:", "blue", "", "") + " creating app lost\n"
expected = expected + cmd.Colorfy(t.Add(2*time.Hour).Format(tfmt)+" [app]:", "blue", "", "") + " app lost successfully created\n"
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
command := AppLog{}
transport := testing.Transport{
Message: string(result),
Status: http.StatusOK,
}
client := cmd.NewClient(&http.Client{Transport: &transport}, nil, manager)
command.Flags().Parse(true, []string{"--app", "appName"})
err = command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}