blob: 7bb5e092e556056bbab0892eb7a911b2d4767228 [file] [log] [blame]
// Copyright 2016 The LUCI Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package logging
import (
"fmt"
"testing"
"go.chromium.org/luci/common/logging"
"go.chromium.org/luci/common/logging/memlogger"
"google.golang.org/grpc/grpclog"
. "github.com/smartystreets/goconvey/convey"
)
// TestGRPCLogger assumes that it has exclusive ownership of the grpclog
// package. Each test MUST execute in series, as they install a global logger
// into the grpclog package.
func TestGRPCLogger(t *testing.T) {
Convey(`Testing gRPC logger adapter`, t, func() {
var base memlogger.MemLogger
// Override "fatalExit" so our Fatal* tests don't actually exit.
exitCalls := 0
fatalExit = func() {
exitCalls++
}
for _, l := range []logging.Level{
logging.Debug,
logging.Info,
logging.Warning,
logging.Error,
Suppress,
} {
var name string
if l == Suppress {
name = "SUPPRESSED"
} else {
name = l.String()
}
Convey(fmt.Sprintf(`At logging level %q`, name), func() {
Convey(`Logs correctly`, func() {
Install(&base, l)
// expected will accumulate during logging based on the current test
// log level, "l".
var expected []memlogger.LogEntry
// Info
grpclog.Info("info", "foo", "bar")
grpclog.Infof("infof(%q, %q)", "foo", "bar")
grpclog.Infoln("infoln", "foo", "bar")
switch l {
case Suppress, logging.Error, logging.Warning, logging.Info:
default:
expected = append(expected, []memlogger.LogEntry{
{logging.Debug, "info foo bar", nil, 3},
{logging.Debug, `infof("foo", "bar")`, nil, 3},
{logging.Debug, "infoln foo bar", nil, 3},
}...)
}
// Warning
grpclog.Warning("warning", "foo", "bar")
grpclog.Warningf("warningf(%q, %q)", "foo", "bar")
grpclog.Warningln("warningln", "foo", "bar")
switch l {
case Suppress, logging.Error:
default:
expected = append(expected, []memlogger.LogEntry{
{logging.Warning, "warning foo bar", nil, 3},
{logging.Warning, `warningf("foo", "bar")`, nil, 3},
{logging.Warning, "warningln foo bar", nil, 3},
}...)
}
// Error
grpclog.Error("error", "foo", "bar")
grpclog.Errorf("errorf(%q, %q)", "foo", "bar")
grpclog.Errorln("errorln", "foo", "bar")
switch l {
case Suppress:
default:
expected = append(expected, []memlogger.LogEntry{
{logging.Error, "error foo bar", nil, 3},
{logging.Error, `errorf("foo", "bar")`, nil, 3},
{logging.Error, "errorln foo bar", nil, 3},
}...)
}
So(base.Messages(), ShouldResemble, expected)
for i := 0; i < 3; i++ {
exp := i <= translateLevel(l)
t.Logf("Testing %q V(%d) => %v", name, i, exp)
So(grpclog.V(i), ShouldEqual, exp)
}
})
// XXX: disabled, pending https://github.com/grpc/grpc-go/issues/1360
SkipConvey(`Handles Fatal calls`, func() {
grpclog.Fatal("fatal", "foo", "bar")
grpclog.Fatalf("fatalf(%q, %q)", "foo", "bar")
grpclog.Fatalln("fatalln", "foo", "bar")
So(base.Messages(), ShouldResemble, []memlogger.LogEntry{
{logging.Error, "fatal foo bar", nil, 3},
{logging.Error, `fatalf("foo", "bar")`, nil, 3},
{logging.Error, "fatalln foo bar", nil, 3},
})
So(exitCalls, ShouldEqual, 3)
})
})
}
})
}