glog/exporter_test.go at master · DataWorkbench/glog · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package glog

import (
	"bytes"
	"context"
	"reflect"
	"testing"
	"unsafe"

	"github.com/stretchr/testify/require"
)

type CustomExporter struct {
	record *Record
}

func (exp *CustomExporter) Export(record *Record) (err error) {
	exp.record = record
	return
}

func (exp *CustomExporter) Close() (err error) {
	return
}

func TestExporter_Custom(t *testing.T) {
	type ctxKey struct{}
	ctx := context.WithValue(context.Background(), ctxKey{}, "v1")

	export := &CustomExporter{}

	l := NewDefault().WithExporter(export).WithContext(ctx)

	msg1 := "Hello One World"
	l.Debug().Msg(msg1).Fire()
	require.NotNil(t, export.record)
	require.Equal(t, ctx, export.record.Context())
	require.Equal(t, DebugLevel, export.record.Level())
	require.Contains(t, string(export.record.Bytes()), msg1)
	require.Contains(t, string(export.record.Copy()), msg1)

	msg2 := "Hello Two World"
	l.Info().Msg(msg2).Fire()
	require.NotNil(t, export.record)
	require.Equal(t, InfoLevel, export.record.Level())
	require.Contains(t, string(export.record.Bytes()), msg2)
	require.Contains(t, string(export.record.Copy()), msg2)

	// Test copy
	b1 := export.record.Bytes()
	b2 := export.record.Bytes()
	b3 := export.record.Copy()
	p1 := (*reflect.SliceHeader)(unsafe.Pointer(&b1))
	p2 := (*reflect.SliceHeader)(unsafe.Pointer(&b2))
	p3 := (*reflect.SliceHeader)(unsafe.Pointer(&b3))

	require.Equal(t, p1, p2)
	require.NotEqual(t, p1, p3)
}

func TestMultipleExporter(t *testing.T) {
	var b1, b2 bytes.Buffer

	e1 := FilterExporter(&b1, MatchGTELevel(DebugLevel))
	e2 := FilterExporter(&b2, MatchGTELevel(ErrorLevel))

	l := NewDefault().WithExporter(MultipleExporter(e1, e2))

	l.Debug().Msg("DebugMessage").Fire()
	l.Info().Msg("InfoMessage").Fire()
	l.Error().Msg("ErrorMessage").Fire()
	l.Fatal().Msg("FatalMessage").Fire()

	s1 := b1.String()
	require.Contains(t, s1, "DebugMessage")
	require.Contains(t, s1, "InfoMessage")
	require.Contains(t, s1, "ErrorMessage")
	require.Contains(t, s1, "FatalMessage")

	s2 := b2.String()
	require.NotContains(t, s2, "DebugMessage")
	require.NotContains(t, s2, "InfoMessage")
	require.Contains(t, s2, "ErrorMessage")
	require.Contains(t, s2, "FatalMessage")
}

type writerCloser1 struct {
	isClosed bool
}

func (exp *writerCloser1) Write(p []byte) (n int, err error) {
	return
}

func (exp *writerCloser1) Close() (err error) {
	exp.isClosed = true
	return
}

func TestStandardExporter_Close(t *testing.T) {
	writer := &writerCloser1{}
	exporter := StandardExporter(writer)
	_ = exporter.Close()

	require.True(t, writer.isClosed)
}