Add tests for text_formatter

text_formatter.go

@@ -2,8 +2,11 @@ package logrus
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
+	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -16,8 +19,18 @@ const (
 	blue    = 34
 )
 
+// {color}level{end-color}[seconds] msg    key=value key=value
+var colorRE *regexp.Regexp
+
+// {color}key{end-color}=value
+var kvRE *regexp.Regexp
+
 func init() {
 	baseTimestamp = time.Now()
+
+	// \x1b is CSI (Control Sequence Introducer)
+	colorRE = regexp.MustCompile(`^\x1b\[\d+m(\w+)\x1b\[0m\[(\d+)\] (.*?) *(\x1b.*)?\r?\n?$`)
+	kvRE = regexp.MustCompile(`\x1b\[\d+m([^\x1b]+)\x1b\[0m=([^\x1b]+)(?:\s+|$)`)
 }
 
 func miniTS() int {
@@ -81,3 +94,91 @@ func (f *TextFormatter) AppendKeyValue(b *bytes.Buffer, key, value interface{})
 		fmt.Fprintf(b, "%v=%v ", key, value)
 	}
 }
+
+func (f *TextFormatter) Unformat(buffer []byte) (*Entry, error) {
+	if len(buffer) == 0 {
+		return nil, errors.New("Missing input")
+	}
+
+	if buffer[0] == '\x1b' {
+		return f.unformatColor(buffer)
+	} else {
+		return f.unformatPlain(buffer)
+	}
+}
+
+func (f *TextFormatter) unformatColor(buffer []byte) (*Entry, error) {
+	// whole match, level, seconds, msg, key-value pairs
+	results := colorRE.FindStringSubmatch(string(buffer))
+	if results == nil {
+		return nil, errors.New("Cannot parse input")
+	}
+
+	var err error
+	var e Entry
+
+	e.Data = make(Fields)
+
+	e.Data["level"], err = f.standardLevelForString(results[1])
+	if err != nil {
+		return nil, err
+	}
+
+	t, err := f.timeForOffsetString(results[2])
+	if err != nil {
+		return nil, err
+	}
+	e.Data["time"] = t.String()
+
+	e.Data["msg"] = results[3]
+
+	for key, value := range f.fieldsForString(results[4]) {
+		e.Data[key] = value
+	}
+
+	return &e, nil
+}
+
+func (f *TextFormatter) standardLevelForString(s string) (string, error) {
+	switch s {
+	case "PANI":
+		return "panic", nil
+	case "FATA":
+		return "fatal", nil
+	case "ERRO":
+		return "error", nil
+	case "WARN":
+		return "warning", nil
+	case "INFO":
+		return "info", nil
+	case "DEBU":
+		return "debug", nil
+	default:
+		return "", fmt.Errorf("Could not parse level: %s", s)
+	}
+}
+
+func (f *TextFormatter) timeForOffsetString(s string) (time.Time, error) {
+	sec, err := strconv.Atoi(s)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("Could not parse time: %s", s)
+	}
+
+	var t time.Time // Zero-time is the epoch (midnight on 1/1/1)
+	t.Add(time.Duration(sec) * time.Second)
+
+	return t, nil
+}
+
+func (f *TextFormatter) fieldsForString(s string) Fields {
+	var fields Fields = make(Fields)
+	for _, kv := range kvRE.FindAllStringSubmatch(s, -1) {
+		fields[kv[1]] = kv[2]
+	}
+
+	return fields
+}
+
+func (f *TextFormatter) unformatPlain(buffer []byte) (*Entry, error) {
+	return nil, errors.New("Unimplemented")
+}

text_formatter_test.go

@@ -0,0 +1,46 @@
+package logrus
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func LogAndAssertText(t *testing.T, log func(*Logger), assertions func(Fields)) {
+	var buffer bytes.Buffer
+
+	logger := New()
+	logger.Out = &buffer
+	formatter := new(TextFormatter)
+	logger.Formatter = formatter
+
+	log(logger)
+
+	entry, err := formatter.Unformat(buffer.Bytes())
+	assert.Nil(t, err)
+
+	if assert.NotNil(t, entry) {
+		assertions(entry.Data)
+	}
+}
+
+func TestTextPrint(t *testing.T) {
+	LogAndAssertText(t, func(log *Logger) {
+		log.Print("test")
+	}, func(fields Fields) {
+		assert.Equal(t, fields["msg"], "test")
+		assert.Equal(t, fields["level"], "info")
+	})
+}
+
+func TestTextMultiData(t *testing.T) {
+	LogAndAssertText(t, func(log *Logger) {
+		log.WithField("wow", "pink elephant").WithField("such", "big whale").Print("test with spaces")
+	}, func(fields Fields) {
+		assert.Equal(t, fields["msg"], "test with spaces")
+		assert.Equal(t, fields["level"], "info")
+		assert.Equal(t, fields["wow"], "pink elephant")
+		assert.Equal(t, fields["such"], "big whale")
+	})
+}