@marcel91200 / caddy Mirror · read-only
Fork 0

Fast and extensible multi-platform HTTP/1-2-3 web server with automatic HTTPS

Mirrored from https://github.com/Slazee/caddy.git

Synced Nov 11, 01:00 UTC

Code Commits Issues Pulls Cloud Agent CICD
master
master
go 155 lines 3.75 KB
Raw
1 package logging
2
3 import (
4 "context"
5 "encoding/json"
6 "strings"
7 "testing"
8 "time"
9
10 "github.com/caddyserver/caddy/v2"
11 "go.uber.org/zap/buffer"
12 "go.uber.org/zap/zapcore"
13
14 "github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
15 )
16
17 func TestJournaldPriorityPrefix(t *testing.T) {
18 tests := []struct {
19 level zapcore.Level
20 want string
21 }{
22 {level: zapcore.InvalidLevel, want: "<6>"},
23 {level: zapcore.DebugLevel, want: "<7>"},
24 {level: zapcore.InfoLevel, want: "<6>"},
25 {level: zapcore.WarnLevel, want: "<4>"},
26 {level: zapcore.ErrorLevel, want: "<3>"},
27 {level: zapcore.DPanicLevel, want: "<2>"},
28 {level: zapcore.PanicLevel, want: "<2>"},
29 {level: zapcore.FatalLevel, want: "<2>"},
30 }
31
32 for _, tt := range tests {
33 t.Run(tt.level.String(), func(t *testing.T) {
34 if got := journaldPriorityPrefix(tt.level); got != tt.want {
35 t.Fatalf("got %s, want %s", got, tt.want)
36 }
37 })
38 }
39 }
40
41 func TestJournaldEncoderEncodeEntry(t *testing.T) {
42 tests := []struct {
43 name string
44 level zapcore.Level
45 want string
46 }{
47 {name: "debug", level: zapcore.DebugLevel, want: "<7>wrapped\n"},
48 {name: "info", level: zapcore.InfoLevel, want: "<6>wrapped\n"},
49 {name: "warn", level: zapcore.WarnLevel, want: "<4>wrapped\n"},
50 {name: "error", level: zapcore.ErrorLevel, want: "<3>wrapped\n"},
51 {name: "panic", level: zapcore.PanicLevel, want: "<2>wrapped\n"},
52 }
53
54 for _, tt := range tests {
55 t.Run(tt.name, func(t *testing.T) {
56 enc := JournaldEncoder{Encoder: staticEncoder{output: "wrapped\n"}}
57 buf, err := enc.EncodeEntry(zapcore.Entry{Level: tt.level}, nil)
58 if err != nil {
59 t.Fatalf("EncodeEntry() error = %v", err)
60 }
61 defer buf.Free()
62
63 if got := buf.String(); got != tt.want {
64 t.Fatalf("got %q, want %q", got, tt.want)
65 }
66 })
67 }
68 }
69
70 func TestJournaldEncoderUnmarshalCaddyfile(t *testing.T) {
71 d := caddyfile.NewTestDispenser(`
72 journald {
73 wrap console
74 }
75 `)
76
77 var enc JournaldEncoder
78 if err := enc.UnmarshalCaddyfile(d); err != nil {
79 t.Fatalf("UnmarshalCaddyfile() error = %v", err)
80 }
81
82 var got map[string]any
83 if err := json.Unmarshal(enc.WrappedRaw, &got); err != nil {
84 t.Fatalf("unmarshal wrapped encoder: %v", err)
85 }
86
87 if got["format"] != "console" {
88 t.Fatalf("wrapped format = %v, want console", got["format"])
89 }
90 }
91
92 func TestJournaldEncoderPreservesJSONTimestamp(t *testing.T) {
93 enc := &JournaldEncoder{
94 Encoder: &JSONEncoder{},
95 }
96 if err := enc.Provision(caddy.Context{Context: context.Background()}); err != nil {
97 t.Fatalf("Provision() error = %v", err)
98 }
99
100 buf, err := enc.EncodeEntry(zapcore.Entry{
101 Level: zapcore.InfoLevel,
102 Time: fixedEntryTime(),
103 Message: "hello",
104 }, nil)
105 if err != nil {
106 t.Fatalf("EncodeEntry() error = %v", err)
107 }
108 defer buf.Free()
109
110 got := buf.String()
111 if !strings.Contains(got, `"ts"`) {
112 t.Fatalf("got JSON output without ts field: %q", got)
113 }
114 }
115
116 func TestJournaldEncoderSuppressesConsoleTimestamp(t *testing.T) {
117 enc := &JournaldEncoder{
118 Encoder: &ConsoleEncoder{},
119 }
120 if err := enc.Provision(caddy.Context{Context: context.Background()}); err != nil {
121 t.Fatalf("Provision() error = %v", err)
122 }
123
124 buf, err := enc.EncodeEntry(zapcore.Entry{
125 Level: zapcore.InfoLevel,
126 Time: fixedEntryTime(),
127 Message: "hello",
128 }, nil)
129 if err != nil {
130 t.Fatalf("EncodeEntry() error = %v", err)
131 }
132 defer buf.Free()
133
134 got := buf.String()
135 if strings.Contains(got, "2001/02/03") {
136 t.Fatalf("got console output with timestamp: %q", got)
137 }
138 }
139
140 type staticEncoder struct {
141 nopEncoder
142 output string
143 }
144
145 func (se staticEncoder) Clone() zapcore.Encoder { return se }
146
147 func (se staticEncoder) EncodeEntry(zapcore.Entry, []zapcore.Field) (*buffer.Buffer, error) {
148 buf := bufferpool.Get()
149 buf.AppendString(se.output)
150 return buf, nil
151 }
152
153 func fixedEntryTime() (ts time.Time) {
154 return time.Date(2001, 2, 3, 4, 5, 6, 0, time.UTC)
155 }