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) TestJsonWriterChukedWrite(c *gocheck.C) {
t := time.Now()
logs := []log{
{Date: t, Message: "Something happened", Source: "tsuru"},
{Date: t.Add(2 * time.Hour), Message: "Something happened again", Source: "tsuru"},
}
data, err := json.Marshal(logs)
c.Assert(err, gocheck.IsNil)
l := len(data)
var buf bytes.Buffer
w := jsonWriter{w: &buf}
_, err = w.Write(data[:l/4])
c.Assert(err, gocheck.IsNil)
c.Assert(buf.String(), gocheck.Equals, "")
_, err = w.Write(data[l/4 : l/2])
c.Assert(err, gocheck.IsNil)
c.Assert(buf.String(), gocheck.Equals, "")
_, err = w.Write(data[l/2 : l/4*3])
c.Assert(err, gocheck.IsNil)
c.Assert(buf.String(), gocheck.Equals, "")
_, err = w.Write(data[l/4*3:])
c.Assert(err, gocheck.IsNil)
tfmt := "2006-01-02 15:04:05 -0700"
expected := cmd.Colorfy(t.Format(tfmt)+" [tsuru]:", "blue", "", "") + " Something happened\n"
expected = expected + cmd.Colorfy(t.Add(2*time.Hour).Format(tfmt)+" [tsuru]:", "blue", "", "") + " Something happened again\n"
c.Assert(buf.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)
}
func (s *S) TestAppLogWithFollow(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: "tsuru"},
}
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)+" [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: 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, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, expected)
}
func (s *S) TestAppLogBySource(c *C) {
*LogSource = "mysource"
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 [tsuru]:", "blue", "", "") + " creating app lost\n"
expected = expected + cmd.Colorfy("2012-06-20 11:17:22 [tsuru]:", "blue", "", "") + " app lost successfully created\n"
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
fake := &FakeGuesser{name: "hitthelights"}
command := AppLog{GuessingCommand{G: fake}}
trans := &conditionalTransport{
transport{
msg: result,
status: http.StatusOK,
},
func(req *http.Request) bool {
return req.URL.Query().Get("source") == "mysource"
},
}
client := cmd.NewClient(&http.Client{Transport: trans}, nil, manager)
err := command.Run(&context, client)
c.Assert(err, IsNil)
got := stdout.String()
got = strings.Replace(got, "-0300 -0300", "-0300 BRT", -1)
c.Assert(got, Equals, expected)
}
func (c *AppLog) Run(context *cmd.Context, client cmd.Doer) error {
appName, err := c.Guess()
if err != nil {
return err
}
url := cmd.GetUrl(fmt.Sprintf("/apps/%s/log?lines=%d", appName, *LogLines))
if LogSource != nil && *LogSource != "" {
url = fmt.Sprintf("%s&source=%s", url, *LogSource)
}
request, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
response, err := client.Do(request)
if err != nil {
return err
}
if response.StatusCode == http.StatusNoContent {
return nil
}
defer response.Body.Close()
result, err := ioutil.ReadAll(response.Body)
logs := []log{}
err = json.Unmarshal(result, &logs)
if err != nil {
return err
}
for _, l := range logs {
date := l.Date.Format("2006-01-02 15:04:05")
prefix := fmt.Sprintf("%s [%s]:", date, l.Source)
msg := fmt.Sprintf("%s %s\n", cmd.Colorfy(prefix, "blue", "", ""), l.Message)
context.Stdout.Write([]byte(msg))
}
return err
}
func (s *S) TestAppLog(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":"app","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 [app]:", "blue", "", "") + " app lost successfully created\n"
context := cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
command := AppLog{}
client := cmd.NewClient(&http.Client{Transport: &testing.Transport{Message: result, Status: http.StatusOK}}, nil, manager)
command.Flags().Parse(true, []string{"--app", "appName"})
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) TestJsonWriter(c *gocheck.C) {
t := time.Now()
logs := []log{
{Date: t, Message: "Something happened", Source: "tsuru"},
{Date: t.Add(2 * time.Hour), Message: "Something happened again", Source: "tsuru"},
}
b, err := json.Marshal(logs)
c.Assert(err, gocheck.IsNil)
var writer bytes.Buffer
w := jsonWriter{w: &writer}
n, err := w.Write(b)
c.Assert(err, gocheck.IsNil)
c.Assert(n, gocheck.Equals, len(b))
tfmt := "2006-01-02 15:04:05 -0700"
expected := cmd.Colorfy(t.Format(tfmt)+" [tsuru]:", "blue", "", "") + " Something happened\n"
expected = expected + cmd.Colorfy(t.Add(2*time.Hour).Format(tfmt)+" [tsuru]:", "blue", "", "") + " Something happened again\n"
c.Assert(writer.String(), gocheck.Equals, expected)
}
func (s *S) TestJsonWriterUsesCurrentTimeZone(c *gocheck.C) {
t := time.Now()
logs := []log{
{Date: t, Message: "Something happened", Source: "tsuru"},
{Date: t.Add(2 * time.Hour), Message: "Something happened again", Source: "tsuru"},
}
data, err := json.Marshal(logs)
c.Assert(err, gocheck.IsNil)
var writer bytes.Buffer
w := jsonWriter{w: &writer}
old := time.Local
time.Local = time.UTC
defer func() {
time.Local = old
}()
w.Write(data)
tfmt := "2006-01-02 15:04:05 -0700"
t = t.In(time.UTC)
expected := cmd.Colorfy(t.Format(tfmt)+" [tsuru]:", "blue", "", "") + " Something happened\n"
expected = expected + cmd.Colorfy(t.Add(2*time.Hour).Format(tfmt)+" [tsuru]:", "blue", "", "") + " Something happened again\n"
c.Assert(writer.String(), gocheck.Equals, expected)
}
func (j *jsonWriter) Write(b []byte) (int, error) {
var logs []log
err := json.Unmarshal(b, &logs)
if err != nil {
return len(b), nil
}
for _, l := range logs {
date := l.Date.Format("2006-01-02 15:04:05")
prefix := fmt.Sprintf("%s [%s]:", date, l.Source)
fmt.Fprintf(j.w, "%s %s\n", cmd.Colorfy(prefix, "blue", "", ""), l.Message)
}
return len(b), nil
}
func (w *jsonWriter) Write(b []byte) (int, error) {
var logs []log
w.b = append(w.b, b...)
err := json.Unmarshal(w.b, &logs)
if err != nil {
return len(b), nil
}
for _, l := range logs {
date := l.Date.In(time.Local).Format("2006-01-02 15:04:05 -0700")
prefix := fmt.Sprintf("%s [%s]:", date, l.Source)
fmt.Fprintf(w.w, "%s %s\n", cmd.Colorfy(prefix, "blue", "", ""), l.Message)
}
w.b = nil
return len(b), nil
}