func (s *S) TestListNodesInTheSchedulerCmdRunWithFilters(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Stdout: &buf}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: `{
"machines": [{"Id": "m-id-1", "Address": "localhost2"}],
"nodes": [
{"Address": "http://localhost1:8080", "Status": "disabled", "Metadata": {"meta1": "foo", "meta2": "bar"}},
{"Address": "http://localhost2:9090", "Status": "disabled", "Metadata": {"meta1": "foo"}}
]
}`, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/1.0/docker/node"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
cmd := listNodesInTheSchedulerCmd{}
cmd.Flags().Parse(true, []string{"--filter", "meta1=foo", "-f", "meta2=bar"})
err := cmd.Run(&context, client)
c.Assert(err, check.IsNil)
expected := `+------------------------+---------+----------+-----------+
| Address | IaaS ID | Status | Metadata |
+------------------------+---------+----------+-----------+
| http://localhost1:8080 | | disabled | meta1=foo |
| | | | meta2=bar |
+------------------------+---------+----------+-----------+
`
c.Assert(buf.String(), check.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) 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) TestListPoolsInTheSchedulerCmdRun(c *check.C) {
var buf bytes.Buffer
pool := provision.Pool{Name: "pool1", Teams: []string{"tsuruteam", "ateam"}}
publicPool := provision.Pool{Name: "pool2", Public: true}
defaultPool := provision.Pool{Name: "pool3", Default: true}
pools := []provision.Pool{pool, publicPool, defaultPool}
poolsJson, _ := json.Marshal(pools)
ctx := cmd.Context{Stdout: &buf}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: string(poolsJson), Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/pool"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
err := listPoolsInTheSchedulerCmd{}.Run(&ctx, client)
c.Assert(err, check.IsNil)
expected := `+-----------------+------------------+---------+
| Pools | Teams | Public |
+-----------------+------------------+---------+
| pool1 | tsuruteam, ateam | |
| pool2 | | X |
| pool3 (default) | | |
+-----------------+------------------+---------+
`
c.Assert(buf.String(), check.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) TestListHealingHistoryCmdRunEmpty(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Stdout: &buf}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: `[]`, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/docker/healing"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
healing := &ListHealingHistoryCmd{}
err := healing.Run(&context, client)
c.Assert(err, check.IsNil)
expected := `Node:
+-------+--------+---------+---------+---------+-------+
| Start | Finish | Success | Failing | Created | Error |
+-------+--------+---------+---------+---------+-------+
Container:
+-------+--------+---------+---------+---------+-------+
| Start | Finish | Success | Failing | Created | Error |
+-------+--------+---------+---------+---------+-------+
`
c.Assert(buf.String(), check.Equals, expected)
}
func (s *S) TestUpdatePoolToTheSchedulerCmd(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Args: []string{"poolTest"}, Stdout: &buf}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: "", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, check.IsNil)
expected := map[string]interface{}{
"default": interface{}(nil),
"public": true,
}
result := map[string]interface{}{}
err = json.Unmarshal(body, &result)
c.Assert(expected, check.DeepEquals, result)
return req.URL.Path == "/pool/poolTest" && req.URL.Query().Get("force") == "false"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
cmd := updatePoolToSchedulerCmd{}
cmd.Flags().Parse(true, []string{"--public", "true"})
err := cmd.Run(&context, client)
c.Assert(err, check.IsNil)
}
func (s *S) TestAppLogWithNoSource(c *check.C) {
var stdout, stderr bytes.Buffer
t := time.Now()
logs := []log{
{Date: t, Message: "GET /", Source: "web"},
{Date: t.Add(2 * time.Hour), Message: "POST /", Source: "web"},
}
result, err := json.Marshal(logs)
c.Assert(err, check.IsNil)
t = t.In(time.Local)
tfmt := "2006-01-02 15:04:05 -0700"
expected := cmd.Colorfy(t.Format(tfmt)+":", "blue", "", "") + " GET /\n"
expected = expected + cmd.Colorfy(t.Add(2*time.Hour).Format(tfmt)+":", "blue", "", "") + " POST /\n"
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
fake := &cmdtest.FakeGuesser{Name: "hitthelights"}
command := appLog{GuessingCommand: cmd.GuessingCommand{G: fake}}
command.Flags().Parse(true, []string{"--lines", "12", "-f", "--no-source"})
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: string(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, check.IsNil)
c.Assert(stdout.String(), check.Equals, expected)
}
func (s *S) TestAppLogWithUnparsableData(c *check.C) {
var stdout, stderr bytes.Buffer
t := time.Now()
logs := []log{
{Date: t, Message: "creating app lost", Source: "tsuru"},
}
result, err := json.Marshal(logs)
c.Assert(err, check.IsNil)
t = t.In(time.Local)
tfmt := "2006-01-02 15:04:05 -0700"
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
command := appLog{}
transport := cmdtest.Transport{
Message: string(result) + "\nunparseable data",
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, check.IsNil)
expected := cmd.Colorfy(t.Format(tfmt)+" [tsuru]:", "blue", "", "") + " creating app lost\n"
expected += "Error: unparseable data"
c.Assert(stdout.String(), check.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", Unit: "abcdef"},
}
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][abcdef]:", "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)
}
func (s *S) TestPoolListRun(c *check.C) {
var stdout, stderr bytes.Buffer
result := `{"pools_by_team": [{"team": "test", "pools": ["pool"]}], "public_pools": [{"name": "public"}],"default_pool": [{"name": "default"}]}}`
context := cmd.Context{
Args: []string{},
Stdout: &stdout,
Stderr: &stderr,
}
expected := `+------+-------+
| Team | Pools |
+------+-------+
| test | pool |
+------+-------+
+--------------+
| Public Pools |
+--------------+
| public |
+--------------+
+--------------+
| Default Pool |
+--------------+
| default |
+--------------+
`
client := cmd.NewClient(&http.Client{Transport: &cmdtest.Transport{Message: result, Status: http.StatusOK}}, nil, manager)
command := poolList{}
err := command.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(stdout.String(), check.Equals, expected)
}
func (s *S) TestAppLogByUnit(c *gocheck.C) {
var stdout, stderr bytes.Buffer
t := time.Now()
logs := []log{
{Date: t, Message: "creating app lost", Source: "tsuru", Unit: "api"},
{Date: t.Add(2 * time.Hour), Message: "app lost successfully created", Source: "tsuru", Unit: "api"},
}
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][api]:", "blue", "", "") + " creating app lost\n"
expected = expected + cmd.Colorfy(t.Add(2*time.Hour).Format(tfmt)+" [tsuru][api]:", "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{"--unit", "api"})
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: string(result), Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Query().Get("unit") == "api"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err = command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestDockerLogUpdateRun(c *check.C) {
var stdout, stderr bytes.Buffer
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
msg := tsuruIo.SimpleJsonMessage{Message: "success!!!"}
result, _ := json.Marshal(msg)
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: string(result), Status: http.StatusNoContent},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, check.IsNil)
expected := provision.ScopedConfig{
Envs: []provision.Entry{{Name: "a", Value: "1"}, {Name: "b", Value: "2"}, {Name: "log-driver", Value: "x"}},
}
var data logsSetData
err = json.Unmarshal(body, &data)
c.Assert(err, check.IsNil)
sort.Sort(provision.ConfigEntryList(data.Config.Envs))
c.Assert(data.Config, check.DeepEquals, expected)
return req.URL.Path == "/1.0/docker/logs" && req.Method == "POST"
},
}
manager := cmd.NewManager("admin", "0.1", "admin-ver", &stdout, &stderr, nil, nil)
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
cmd := dockerLogUpdate{}
err := cmd.Flags().Parse(true, []string{"--log-driver", "x", "--log-opt", "a=1", "--log-opt", "b=2"})
c.Assert(err, check.IsNil)
err = cmd.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(stdout.String(), check.Equals, "success!!!")
}
func (s *S) TestUpdateNodeToTheSchedulerCmdRun(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Args: []string{"http://localhost:1111", "x=y", "y=z"}, Stdout: &buf}
expectedBody := map[string]string{
"address": "http://localhost:1111",
"x": "y",
"y": "z",
}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: "", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
body, _ := ioutil.ReadAll(req.Body)
var parsed map[string]string
err := json.Unmarshal(body, &parsed)
c.Assert(err, check.IsNil)
c.Assert(parsed, check.DeepEquals, expectedBody)
return req.URL.Path == "/1.0/docker/node" && req.Method == "PUT" && req.URL.Query().Get("disabled") == "false"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
cmd := updateNodeToSchedulerCmd{}
err := cmd.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(buf.String(), check.Equals, "Node successfully updated.\n")
}
func (s *S) TestAutoScaleHistoryInProgressEndTimeCmdRun(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Stdout: &buf}
msg := fmt.Sprintf(`[{
"StartTime": "2015-10-23T08:00:00.000Z",
"EndTime": "%s",
"Successful": true,
"Action": "add",
"Reason": "",
"MetadataValue": "poolx",
"Error": ""
}]`, time.Time{}.Format(time.RFC3339))
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: msg, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/1.0/docker/autoscale"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
autoscale := &listAutoScaleHistoryCmd{}
err := autoscale.Run(&context, client)
c.Assert(err, check.IsNil)
timeFormat, err := time.Parse(time.RFC3339, "2015-10-23T08:00:00.000Z")
c.Assert(err, check.IsNil)
startTime := timeFormat.Local().Format(time.Stamp)
expected := fmt.Sprintf(`+-----------------+-------------+---------+----------+--------+--------+-------+
| Start | Finish | Success | Metadata | Action | Reason | Error |
+-----------------+-------------+---------+----------+--------+--------+-------+
| %s | in progress | true | poolx | add | | |
+-----------------+-------------+---------+----------+--------+--------+-------+
`, startTime)
c.Assert(buf.String(), check.Equals, expected)
}
func (s *S) TestAppLogWithoutTheFlag(c *check.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, check.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,
}
fake := &cmdtest.FakeGuesser{Name: "hitthelights"}
command := appLog{GuessingCommand: cmd.GuessingCommand{G: fake}}
command.Flags().Parse(true, nil)
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: string(result), Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/apps/hitthelights/log" && req.Method == "GET" &&
req.URL.Query().Get("lines") == "10"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err = command.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(stdout.String(), check.Equals, expected)
}
func (s *S) TestListHealingHistoryCmdRun(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Stdout: &buf}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: healingJsonData, Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
return req.URL.Path == "/docker/healing"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
healing := &ListHealingHistoryCmd{}
err := healing.Run(&context, client)
c.Assert(err, check.IsNil)
startT, _ := time.Parse(time.RFC3339, "2014-10-23T08:00:00.000Z")
endT, _ := time.Parse(time.RFC3339, "2014-10-23T08:30:00.000Z")
startTStr := startT.Local().Format(time.Stamp)
endTStr := endT.Local().Format(time.Stamp)
expected := fmt.Sprintf(`Node:
+-----------------+-----------------+---------+---------+---------+-------+
| Start | Finish | Success | Failing | Created | Error |
+-----------------+-----------------+---------+---------+---------+-------+
| %s | %s | true | addr1 | addr2 | |
+-----------------+-----------------+---------+---------+---------+-------+
Container:
+-----------------+-----------------+---------+------------+------------+-------+
| Start | Finish | Success | Failing | Created | Error |
+-----------------+-----------------+---------+------------+------------+-------+
| %s | %s | false | 1234567890 | | err1 |
+-----------------+-----------------+---------+------------+------------+-------+
| %s | %s | true | 1234567890 | 9234567890 | |
+-----------------+-----------------+---------+------------+------------+-------+
`, startTStr, endTStr, startTStr, endTStr, startTStr, endTStr)
c.Assert(buf.String(), check.Equals, expected)
}
func (s *S) TestAppInfo(c *gocheck.C) {
var stdout, stderr bytes.Buffer
result := `{"name":"app1","cname":"","ip":"myapp.tsuru.io","platform":"php","repository":"[email protected]:php.git","state":"dead", "units":[{"Ip":"10.10.10.10","Name":"app1/0","Status":"started"}, {"Ip":"9.9.9.9","Name":"app1/1","Status":"started"}, {"Ip":"","Name":"app1/2","Status":"pending"}],"teams":["tsuruteam","crane"], "owner": "myapp_owner", "deploys": 7}`
expected := `Application: app1
Repository: [email protected]:php.git
Platform: php
Teams: tsuruteam, crane
Address: myapp.tsuru.io
Owner: myapp_owner
Deploys: 7
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: &testing.Transport{Message: 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) TestFailToAddMoreThanOneDefaultPool(c *check.C) {
var buf bytes.Buffer
stdin := bytes.NewBufferString("no")
transportError := cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Status: http.StatusPreconditionFailed, Message: "Default pool already exist."},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, check.IsNil)
expected := map[string]interface{}{
"name": "test",
"public": false,
"default": true,
}
result := map[string]interface{}{}
err = json.Unmarshal(body, &result)
c.Assert(expected, check.DeepEquals, result)
return req.URL.Path == "/pool"
},
}
manager := cmd.Manager{}
context := cmd.Context{Args: []string{"test"}, Stdout: &buf, Stdin: stdin}
client := cmd.NewClient(&http.Client{Transport: &transportError}, nil, &manager)
command := addPoolToSchedulerCmd{}
command.Flags().Parse(true, []string{"-d"})
err := command.Run(&context, client)
c.Assert(err, check.IsNil)
expected := "WARNING: Default pool already exist. Do you want change to test pool? (y/n) Pool add aborted.\n"
c.Assert(buf.String(), check.Equals, expected)
}
func (s *S) TestSetCName(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
Args: []string{"death.evergrey.mycompany.com"},
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: "Restarted", Status: http.StatusOK},
CondFunc: 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/cname" &&
req.Method == "POST" &&
m["cname"] == "death.evergrey.mycompany.com"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := SetCName{}
command.Flags().Parse(true, []string{"-a", "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 defined.\n")
}
func (s *S) TestForceToOverwriteDefaultPoolInUpdate(c *check.C) {
var buf bytes.Buffer
stdin := bytes.NewBufferString("no")
transportError := cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Status: http.StatusPreconditionFailed, Message: "Default pool already exist."},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, check.IsNil)
expected := map[string]interface{}{
"default": true,
"public": interface{}(nil),
}
result := map[string]interface{}{}
err = json.Unmarshal(body, &result)
c.Assert(result, check.DeepEquals, expected)
return req.URL.Path == "/pool/test" && req.URL.Query().Get("force") == "true"
},
}
manager := cmd.Manager{}
context := cmd.Context{Args: []string{"test"}, Stdout: &buf, Stdin: stdin}
client := cmd.NewClient(&http.Client{Transport: &transportError}, nil, &manager)
command := updatePoolToSchedulerCmd{}
command.Flags().Parse(true, []string{"--default=true"})
command.Flags().Parse(true, []string{"-f"})
err := command.Run(&context, client)
c.Assert(err, check.IsNil)
}
func (s *S) TestSetCNameWithoutTheFlag(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
Args: []string{"corey.evergrey.mycompany.com"},
}
fake := &FakeGuesser{name: "corey"}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: "Restarted", Status: http.StatusOK},
CondFunc: 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/cname" &&
req.Method == "POST" &&
m["cname"] == "corey.evergrey.mycompany.com"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := (&SetCName{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 defined.\n")
}
func (s *S) TestAddDefaultPool(c *check.C) {
var buf bytes.Buffer
context := cmd.Context{Args: []string{"test"}, Stdout: &buf}
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: "", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, check.IsNil)
expected := map[string]interface{}{
"name": "test",
"public": false,
"default": true,
}
result := map[string]interface{}{}
err = json.Unmarshal(body, &result)
c.Assert(expected, check.DeepEquals, result)
return req.URL.Path == "/pool"
},
}
manager := cmd.Manager{}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
command := addPoolToSchedulerCmd{}
command.Flags().Parse(true, []string{"-d"})
err := command.Run(&context, client)
c.Assert(err, check.IsNil)
}
func (s *S) TestAppStopWithoutTheFlag(c *gocheck.C) {
var (
called bool
stdout, stderr bytes.Buffer
)
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: "Stopped", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
called = true
return req.URL.Path == "/apps/motorbreath/stop" && req.Method == "POST"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
fake := &FakeGuesser{name: "motorbreath"}
command := AppStop{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, "Stopped")
}
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) TestAutoScaleSetRuleCmdRun(c *check.C) {
var called bool
transport := cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: "", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
called = true
err := req.ParseForm()
c.Assert(err, check.IsNil)
var rule autoScaleRule
err = form.DecodeValues(&rule, req.Form)
c.Assert(err, check.IsNil)
c.Assert(rule, check.DeepEquals, autoScaleRule{
MetadataFilter: "pool1",
Enabled: true,
MaxContainerCount: 10,
MaxMemoryRatio: 1.2342,
ScaleDownRatio: 1.33,
PreventRebalance: false,
})
return req.Method == "POST" && req.URL.Path == "/1.0/docker/autoscale/rules"
},
}
var buf bytes.Buffer
context := cmd.Context{Stdout: &buf}
var manager cmd.Manager
client := cmd.NewClient(&http.Client{Transport: &transport}, nil, &manager)
var command autoScaleSetRuleCmd
flags := []string{"-f", "pool1", "-c", "10", "-m", "1.2342", "--enable"}
err := command.Flags().Parse(true, flags)
c.Assert(err, check.IsNil)
err = command.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(called, check.Equals, true)
c.Assert(buf.String(), check.Equals, "Rule successfully defined.\n")
}
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) TestDockerLogUpdateForPoolRun(c *check.C) {
var stdout, stderr bytes.Buffer
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
msg := tsuruIo.SimpleJsonMessage{Message: "success!!!"}
result, _ := json.Marshal(msg)
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: string(result), Status: http.StatusNoContent},
CondFunc: func(req *http.Request) bool {
err := req.ParseForm()
c.Assert(err, check.IsNil)
c.Assert(req.Form, check.DeepEquals, url.Values{
"restart": []string{"false"},
"pool": []string{"p1"},
"Driver": []string{"x"},
"LogOpts.a": []string{"1"},
"LogOpts.b": []string{"2"},
})
return req.URL.Path == "/1.0/docker/logs" && req.Method == "POST"
},
}
manager := cmd.NewManager("admin", "0.1", "admin-ver", &stdout, &stderr, nil, nil)
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
cmd := dockerLogUpdate{}
err := cmd.Flags().Parse(true, []string{"--pool", "p1", "--log-driver", "x", "--log-opt", "a=1", "--log-opt", "b=2"})
c.Assert(err, check.IsNil)
err = cmd.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(stdout.String(), check.Equals, "success!!!")
}
func (s *S) TestPlatformAddRun(c *gocheck.C) {
var stdout, stderr bytes.Buffer
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
Args: []string{"teste"},
}
expected := "Platform successfully added!\n"
trans := &testing.ConditionalTransport{
Transport: testing.Transport{Message: "", Status: http.StatusOK},
CondFunc: func(req *http.Request) bool {
c.Assert(req.Header.Get("Content-Type"), gocheck.Equals, "application/x-www-form-urlencoded")
return req.URL.Path == "/platforms" && req.Method == "POST"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
command := platformAdd{}
command.Flags().Parse(true, []string{"--dockerfile", "http://localhost/Dockerfile"})
err := command.Run(&context, client)
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestBsEnvSetRun(c *check.C) {
var stdout, stderr bytes.Buffer
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
Args: []string{"A=1", "B=2"},
}
msg := io.SimpleJsonMessage{Message: "env-set success"}
result, _ := json.Marshal(msg)
trans := &cmdtest.ConditionalTransport{
Transport: cmdtest.Transport{Message: string(result), Status: http.StatusNoContent},
CondFunc: func(req *http.Request) bool {
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
c.Assert(err, check.IsNil)
expected := Config{
Envs: []Env{{Name: "A", Value: "1"}, {Name: "B", Value: "2"}},
}
var conf Config
err = json.Unmarshal(body, &conf)
c.Assert(conf, check.DeepEquals, expected)
return req.URL.Path == "/docker/bs/env" && req.Method == "POST"
},
}
manager := cmd.NewManager("admin", "0.1", "admin-ver", &stdout, &stderr, nil, nil)
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
cmd := EnvSetCmd{}
err := cmd.Run(&context, client)
c.Assert(err, check.IsNil)
c.Assert(stdout.String(), check.Equals, "env-set success")
}