vendor/github.com/sirupsen/logrus/json_formatter_test.go

   1 package logrus
   2
   3 import (
   4         "encoding/json"
   5         "errors"
   6         "strings"
   7         "testing"
   8 )
   9
  10 func TestErrorNotLost(t *testing.T) {
  11         formatter := &JSONFormatter{}
  12
  13         b, err := formatter.Format(WithField("error", errors.New("wild walrus")))
  14         if err != nil {
  15                 t.Fatal("Unable to format entry: ", err)
  16         }
  17
  18         entry := make(map[string]interface{})
  19         err = json.Unmarshal(b, &entry)
  20         if err != nil {
  21                 t.Fatal("Unable to unmarshal formatted entry: ", err)
  22         }
  23
  24         if entry["error"] != "wild walrus" {
  25                 t.Fatal("Error field not set")
  26         }
  27 }
  28
  29 func TestErrorNotLostOnFieldNotNamedError(t *testing.T) {
  30         formatter := &JSONFormatter{}
  31
  32         b, err := formatter.Format(WithField("omg", errors.New("wild walrus")))
  33         if err != nil {
  34                 t.Fatal("Unable to format entry: ", err)
  35         }
  36
  37         entry := make(map[string]interface{})
  38         err = json.Unmarshal(b, &entry)
  39         if err != nil {
  40                 t.Fatal("Unable to unmarshal formatted entry: ", err)
  41         }
  42
  43         if entry["omg"] != "wild walrus" {
  44                 t.Fatal("Error field not set")
  45         }
  46 }
  47
  48 func TestFieldClashWithTime(t *testing.T) {
  49         formatter := &JSONFormatter{}
  50
  51         b, err := formatter.Format(WithField("time", "right now!"))
  52         if err != nil {
  53                 t.Fatal("Unable to format entry: ", err)
  54         }
  55
  56         entry := make(map[string]interface{})
  57         err = json.Unmarshal(b, &entry)
  58         if err != nil {
  59                 t.Fatal("Unable to unmarshal formatted entry: ", err)
  60         }
  61
  62         if entry["fields.time"] != "right now!" {
  63                 t.Fatal("fields.time not set to original time field")
  64         }
  65
  66         if entry["time"] != "0001-01-01T00:00:00Z" {
  67                 t.Fatal("time field not set to current time, was: ", entry["time"])
  68         }
  69 }
  70
  71 func TestFieldClashWithMsg(t *testing.T) {
  72         formatter := &JSONFormatter{}
  73
  74         b, err := formatter.Format(WithField("msg", "something"))
  75         if err != nil {
  76                 t.Fatal("Unable to format entry: ", err)
  77         }
  78
  79         entry := make(map[string]interface{})
  80         err = json.Unmarshal(b, &entry)
  81         if err != nil {
  82                 t.Fatal("Unable to unmarshal formatted entry: ", err)
  83         }
  84
  85         if entry["fields.msg"] != "something" {
  86                 t.Fatal("fields.msg not set to original msg field")
  87         }
  88 }
  89
  90 func TestFieldClashWithLevel(t *testing.T) {
  91         formatter := &JSONFormatter{}
  92
  93         b, err := formatter.Format(WithField("level", "something"))
  94         if err != nil {
  95                 t.Fatal("Unable to format entry: ", err)
  96         }
  97
  98         entry := make(map[string]interface{})
  99         err = json.Unmarshal(b, &entry)
 100         if err != nil {
 101                 t.Fatal("Unable to unmarshal formatted entry: ", err)
 102         }
 103
 104         if entry["fields.level"] != "something" {
 105                 t.Fatal("fields.level not set to original level field")
 106         }
 107 }
 108
 109 func TestJSONEntryEndsWithNewline(t *testing.T) {
 110         formatter := &JSONFormatter{}
 111
 112         b, err := formatter.Format(WithField("level", "something"))
 113         if err != nil {
 114                 t.Fatal("Unable to format entry: ", err)
 115         }
 116
 117         if b[len(b)-1] != '\n' {
 118                 t.Fatal("Expected JSON log entry to end with a newline")
 119         }
 120 }
 121
 122 func TestJSONMessageKey(t *testing.T) {
 123         formatter := &JSONFormatter{
 124                 FieldMap: FieldMap{
 125                         FieldKeyMsg: "message",
 126                 },
 127         }
 128
 129         b, err := formatter.Format(&Entry{Message: "oh hai"})
 130         if err != nil {
 131                 t.Fatal("Unable to format entry: ", err)
 132         }
 133         s := string(b)
 134         if !(strings.Contains(s, "message") && strings.Contains(s, "oh hai")) {
 135                 t.Fatal("Expected JSON to format message key")
 136         }
 137 }
 138
 139 func TestJSONLevelKey(t *testing.T) {
 140         formatter := &JSONFormatter{
 141                 FieldMap: FieldMap{
 142                         FieldKeyLevel: "somelevel",
 143                 },
 144         }
 145
 146         b, err := formatter.Format(WithField("level", "something"))
 147         if err != nil {
 148                 t.Fatal("Unable to format entry: ", err)
 149         }
 150         s := string(b)
 151         if !strings.Contains(s, "somelevel") {
 152                 t.Fatal("Expected JSON to format level key")
 153         }
 154 }
 155
 156 func TestJSONTimeKey(t *testing.T) {
 157         formatter := &JSONFormatter{
 158                 FieldMap: FieldMap{
 159                         FieldKeyTime: "timeywimey",
 160                 },
 161         }
 162
 163         b, err := formatter.Format(WithField("level", "something"))
 164         if err != nil {
 165                 t.Fatal("Unable to format entry: ", err)
 166         }
 167         s := string(b)
 168         if !strings.Contains(s, "timeywimey") {
 169                 t.Fatal("Expected JSON to format time key")
 170         }
 171 }
 172
 173 func TestJSONDisableTimestamp(t *testing.T) {
 174         formatter := &JSONFormatter{
 175                 DisableTimestamp: true,
 176         }
 177
 178         b, err := formatter.Format(WithField("level", "something"))
 179         if err != nil {
 180                 t.Fatal("Unable to format entry: ", err)
 181         }
 182         s := string(b)
 183         if strings.Contains(s, FieldKeyTime) {
 184                 t.Error("Did not prevent timestamp", s)
 185         }
 186 }
 187
 188 func TestJSONEnableTimestamp(t *testing.T) {
 189         formatter := &JSONFormatter{}
 190
 191         b, err := formatter.Format(WithField("level", "something"))
 192         if err != nil {
 193                 t.Fatal("Unable to format entry: ", err)
 194         }
 195         s := string(b)
 196         if !strings.Contains(s, FieldKeyTime) {
 197                 t.Error("Timestamp not present", s)
 198         }
 199 }