slf4g/sdk/bridge/slog/level_test.go at main · echocat/slf4g · 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
//go:build go1.21

package sdk

import (
	"fmt"
	sdk "log/slog"
	"testing"

	"github.com/echocat/slf4g/internal/test/assert"
	"github.com/echocat/slf4g/level"
)

func TestNewLevelMapper(t *testing.T) {
	actualA := NewLevelMapper()
	assert.ToBeNotNil(t, actualA)

	actualB := NewLevelMapper()
	assert.ToBeNotNil(t, actualB)

	assert.ToBeOfType(t, (*defaultLevelMapper)(nil), actualA)
	assert.ToBeOfType(t, (*defaultLevelMapper)(nil), actualB)
}

func TestDefaultLevelMapper_FromSdk(t *testing.T) {
	instance := &defaultLevelMapper{}

	cases := []struct {
		input       sdk.Level
		expected    level.Level
		expectedErr string
	}{
		{LevelTrace, level.Trace, ""},
		{LevelDebug, level.Debug, ""},
		{LevelInfo, level.Info, ""},
		{LevelWarn, level.Warn, ""},
		{LevelError, level.Error, ""},
		{LevelFatal, level.Fatal, ""},
		{666, 0, "unknown slog level: 666"},
	}

	for _, c := range cases {
		t.Run(c.input.String(), func(t *testing.T) {
			actual, actualErr := instance.FromSdk(c.input)
			if c.expectedErr == "" {
				assert.ToBeNoError(t, actualErr)
				assert.ToBeEqual(t, c.expected, actual)
			} else {
				assert.ToBeMatching(t, c.expectedErr, actualErr)
				assert.ToBeEqual(t, level.Level(0), actual)
			}
		})
	}
}

func TestDefaultLevelMapper_ToSdk(t *testing.T) {
	instance := &defaultLevelMapper{}

	cases := []struct {
		input       level.Level
		expected    sdk.Level
		expectedErr string
	}{
		{level.Trace, LevelTrace, ""},
		{level.Debug, LevelDebug, ""},
		{level.Info, LevelInfo, ""},
		{level.Warn, LevelWarn, ""},
		{level.Error, LevelError, ""},
		{level.Fatal, LevelFatal, ""},
		{666, 0, "unknown log level: 666"},
	}

	for _, c := range cases {
		t.Run(fmt.Sprintf("l%d", c.input), func(t *testing.T) {
			actual, actualErr := instance.ToSdk(c.input)
			if c.expectedErr == "" {
				assert.ToBeNoError(t, actualErr)
				assert.ToBeEqual(t, c.expected, actual)
			} else {
				assert.ToBeMatching(t, c.expectedErr, actualErr)
				assert.ToBeEqual(t, sdk.Level(0), actual)
			}
		})
	}
}

func TestLevelMapperFacade_FromSdk(t *testing.T) {
	instance := NewLevelMapperFacade(NewLevelMapper)

	actualA, actualErrA := instance.FromSdk(sdk.LevelDebug)
	assert.ToBeNoError(t, actualErrA)
	assert.ToBeEqual(t, level.Debug, actualA)

	actualB, actualErrB := instance.FromSdk(sdk.Level(666))
	assert.ToBeMatching(t, "unknown slog level: 666", actualErrB)
	assert.ToBeEqual(t, level.Level(0), actualB)
}

func TestLevelMapperFacade_ToSdk(t *testing.T) {
	instance := NewLevelMapperFacade(NewLevelMapper)

	actualA, actualErrA := instance.ToSdk(level.Debug)
	assert.ToBeNoError(t, actualErrA)
	assert.ToBeEqual(t, sdk.LevelDebug, actualA)

	actualB, actualErrB := instance.ToSdk(level.Level(666))
	assert.ToBeMatching(t, "unknown log level: 666", actualErrB)
	assert.ToBeEqual(t, sdk.Level(0), actualB)
}

type testingLevelMapper struct {
	fromSdk func(sdk.Level) (level.Level, error)
	toSdk   func(level.Level) (sdk.Level, error)
}

func (instance *testingLevelMapper) FromSdk(s sdk.Level) (level.Level, error) {
	return instance.fromSdk(s)
}

func (instance *testingLevelMapper) ToSdk(l level.Level) (sdk.Level, error) {
	return instance.toSdk(l)
}