Function TestGrpcLogging

middleware/grpc_logging_test.go:38–100

(t *testing.T)

}

func TestGrpcLogging(t *testing.T) {
	ctx := context.Background()
	info := &grpc.UnaryServerInfo{FullMethod: "Test"}
	for _, tc := range []struct {
		inputErr    error
		expectedErr error
		logContains []string
	}{{
		inputErr:    context.Canceled,
		expectedErr: context.Canceled,
		logContains: []string{"level=debug", "context canceled"},
	}, {
		inputErr:    errors.New("yolo"),
		expectedErr: errors.New("yolo"),
		logContains: []string{"level=warn", "err=yolo"},
	}, {
		inputErr:    nil,
		expectedErr: nil,
		logContains: []string{"level=debug", "method=Test"},
	}, {
		inputErr:    DoNotLogError{Err: errors.New("yolo")},
		expectedErr: DoNotLogError{Err: errors.New("yolo")},
		logContains: nil,
	}, {
		inputErr:    sampledError{err: errors.New("yolo"), shouldLog: true, reason: "sampled 1/10"},
		expectedErr: fmt.Errorf("%w (sampled 1/10)", sampledError{err: errors.New("yolo"), shouldLog: true, reason: "sampled 1/10"}),
		logContains: []string{`err="yolo (sampled 1/10)"`},
	}, {
		inputErr: sampledError{err: errors.New("yolo"), shouldLog: false, reason: "sampled 1/10"},

		// The returned error should have the "sampled" suffix because it has been effectively sampled even if not logged.
		expectedErr: fmt.Errorf("%w (sampled 1/10)", sampledError{err: errors.New("yolo"), shouldLog: false, reason: "sampled 1/10"}),
		logContains: nil,
	}} {
		t.Run("", func(t *testing.T) {
			buf := bytes.NewBuffer(nil)
			logger := log.NewLogfmtLogger(buf)
			l := GRPCServerLog{Log: logger, WithRequest: true, DisableRequestSuccessLog: false}

			handler := func(context.Context, interface{}) (interface{}, error) {
				return nil, tc.inputErr
			}

			_, err := l.UnaryServerInterceptor(ctx, nil, info, handler)

			if tc.expectedErr != nil {
				require.EqualError(t, err, tc.expectedErr.Error())
			} else {
				require.NoError(t, err)
			}

			// The input error should be preserved in the chain.
			require.ErrorIs(t, err, tc.inputErr)

			if len(tc.logContains) == 0 {
				require.Empty(t, buf)
			}
			for _, content := range tc.logContains {