github.com/hashicorp/vault/sdk@v0.13.0/plugin/logger_test.go (about) 1 // Copyright (c) HashiCorp, Inc. 2 // SPDX-License-Identifier: MPL-2.0 3 4 package plugin 5 6 import ( 7 "bufio" 8 "bytes" 9 "io/ioutil" 10 "net/rpc" 11 "strings" 12 "testing" 13 14 hclog "github.com/hashicorp/go-hclog" 15 plugin "github.com/hashicorp/go-plugin" 16 "github.com/hashicorp/vault/sdk/helper/logging" 17 ) 18 19 func TestLogger_levels(t *testing.T) { 20 client, server := plugin.TestRPCConn(t) 21 defer client.Close() 22 23 var buf bytes.Buffer 24 writer := bufio.NewWriter(&buf) 25 26 l := logging.NewVaultLoggerWithWriter(writer, hclog.Trace) 27 28 server.RegisterName("Plugin", &LoggerServer{ 29 logger: l, 30 }) 31 32 expected := "foobar" 33 testLogger := &deprecatedLoggerClient{client: client} 34 35 // Test trace 36 testLogger.Trace(expected) 37 if err := writer.Flush(); err != nil { 38 t.Fatal(err) 39 } 40 result := buf.String() 41 buf.Reset() 42 if !strings.Contains(result, expected) { 43 t.Fatalf("expected log to contain %s, got %s", expected, result) 44 } 45 46 // Test debug 47 testLogger.Debug(expected) 48 if err := writer.Flush(); err != nil { 49 t.Fatal(err) 50 } 51 result = buf.String() 52 buf.Reset() 53 if !strings.Contains(result, expected) { 54 t.Fatalf("expected log to contain %s, got %s", expected, result) 55 } 56 57 // Test debug 58 testLogger.Info(expected) 59 if err := writer.Flush(); err != nil { 60 t.Fatal(err) 61 } 62 result = buf.String() 63 buf.Reset() 64 if !strings.Contains(result, expected) { 65 t.Fatalf("expected log to contain %s, got %s", expected, result) 66 } 67 68 // Test warn 69 testLogger.Warn(expected) 70 if err := writer.Flush(); err != nil { 71 t.Fatal(err) 72 } 73 result = buf.String() 74 buf.Reset() 75 if !strings.Contains(result, expected) { 76 t.Fatalf("expected log to contain %s, got %s", expected, result) 77 } 78 79 // Test error 80 testLogger.Error(expected) 81 if err := writer.Flush(); err != nil { 82 t.Fatal(err) 83 } 84 result = buf.String() 85 buf.Reset() 86 if !strings.Contains(result, expected) { 87 t.Fatalf("expected log to contain %s, got %s", expected, result) 88 } 89 90 // Test fatal 91 testLogger.Fatal(expected) 92 if err := writer.Flush(); err != nil { 93 t.Fatal(err) 94 } 95 result = buf.String() 96 buf.Reset() 97 if result != "" { 98 t.Fatalf("expected log Fatal() to be no-op, got %s", result) 99 } 100 } 101 102 func TestLogger_isLevels(t *testing.T) { 103 client, server := plugin.TestRPCConn(t) 104 defer client.Close() 105 106 l := logging.NewVaultLoggerWithWriter(ioutil.Discard, hclog.Trace) 107 108 server.RegisterName("Plugin", &LoggerServer{ 109 logger: l, 110 }) 111 112 testLogger := &deprecatedLoggerClient{client: client} 113 114 if !testLogger.IsDebug() || !testLogger.IsInfo() || !testLogger.IsTrace() || !testLogger.IsWarn() { 115 t.Fatal("expected logger to return true for all logger level checks") 116 } 117 } 118 119 func TestLogger_log(t *testing.T) { 120 client, server := plugin.TestRPCConn(t) 121 defer client.Close() 122 123 var buf bytes.Buffer 124 writer := bufio.NewWriter(&buf) 125 126 l := logging.NewVaultLoggerWithWriter(writer, hclog.Trace) 127 128 server.RegisterName("Plugin", &LoggerServer{ 129 logger: l, 130 }) 131 132 expected := "foobar" 133 testLogger := &deprecatedLoggerClient{client: client} 134 135 // Test trace 6 = logxi.LevelInfo 136 testLogger.Log(6, expected, nil) 137 if err := writer.Flush(); err != nil { 138 t.Fatal(err) 139 } 140 result := buf.String() 141 if !strings.Contains(result, expected) { 142 t.Fatalf("expected log to contain %s, got %s", expected, result) 143 } 144 } 145 146 func TestLogger_setLevel(t *testing.T) { 147 client, server := plugin.TestRPCConn(t) 148 defer client.Close() 149 150 l := hclog.New(&hclog.LoggerOptions{Output: ioutil.Discard}) 151 152 server.RegisterName("Plugin", &LoggerServer{ 153 logger: l, 154 }) 155 156 testLogger := &deprecatedLoggerClient{client: client} 157 testLogger.SetLevel(4) // 4 == logxi.LevelWarn 158 159 if !testLogger.IsWarn() { 160 t.Fatal("expected logger to support warn level") 161 } 162 } 163 164 type deprecatedLoggerClient struct { 165 client *rpc.Client 166 } 167 168 func (l *deprecatedLoggerClient) Trace(msg string, args ...interface{}) { 169 cArgs := &LoggerArgs{ 170 Msg: msg, 171 Args: args, 172 } 173 l.client.Call("Plugin.Trace", cArgs, &struct{}{}) 174 } 175 176 func (l *deprecatedLoggerClient) Debug(msg string, args ...interface{}) { 177 cArgs := &LoggerArgs{ 178 Msg: msg, 179 Args: args, 180 } 181 l.client.Call("Plugin.Debug", cArgs, &struct{}{}) 182 } 183 184 func (l *deprecatedLoggerClient) Info(msg string, args ...interface{}) { 185 cArgs := &LoggerArgs{ 186 Msg: msg, 187 Args: args, 188 } 189 l.client.Call("Plugin.Info", cArgs, &struct{}{}) 190 } 191 192 func (l *deprecatedLoggerClient) Warn(msg string, args ...interface{}) error { 193 var reply LoggerReply 194 cArgs := &LoggerArgs{ 195 Msg: msg, 196 Args: args, 197 } 198 err := l.client.Call("Plugin.Warn", cArgs, &reply) 199 if err != nil { 200 return err 201 } 202 if reply.Error != nil { 203 return reply.Error 204 } 205 206 return nil 207 } 208 209 func (l *deprecatedLoggerClient) Error(msg string, args ...interface{}) error { 210 var reply LoggerReply 211 cArgs := &LoggerArgs{ 212 Msg: msg, 213 Args: args, 214 } 215 err := l.client.Call("Plugin.Error", cArgs, &reply) 216 if err != nil { 217 return err 218 } 219 if reply.Error != nil { 220 return reply.Error 221 } 222 223 return nil 224 } 225 226 func (l *deprecatedLoggerClient) Fatal(msg string, args ...interface{}) { 227 // NOOP since it's not actually used within vault 228 } 229 230 func (l *deprecatedLoggerClient) Log(level int, msg string, args []interface{}) { 231 cArgs := &LoggerArgs{ 232 Level: level, 233 Msg: msg, 234 Args: args, 235 } 236 l.client.Call("Plugin.Log", cArgs, &struct{}{}) 237 } 238 239 func (l *deprecatedLoggerClient) SetLevel(level int) { 240 l.client.Call("Plugin.SetLevel", level, &struct{}{}) 241 } 242 243 func (l *deprecatedLoggerClient) IsTrace() bool { 244 var reply LoggerReply 245 l.client.Call("Plugin.IsTrace", new(interface{}), &reply) 246 return reply.IsTrue 247 } 248 249 func (l *deprecatedLoggerClient) IsDebug() bool { 250 var reply LoggerReply 251 l.client.Call("Plugin.IsDebug", new(interface{}), &reply) 252 return reply.IsTrue 253 } 254 255 func (l *deprecatedLoggerClient) IsInfo() bool { 256 var reply LoggerReply 257 l.client.Call("Plugin.IsInfo", new(interface{}), &reply) 258 return reply.IsTrue 259 } 260 261 func (l *deprecatedLoggerClient) IsWarn() bool { 262 var reply LoggerReply 263 l.client.Call("Plugin.IsWarn", new(interface{}), &reply) 264 return reply.IsTrue 265 }