go-transaction-manager

1
package trm
2

3
import (
4
	"errors"
5
	"testing"
6

7
	"github.com/stretchr/testify/assert"
8
)
9

10
var errTest = errors.New("test")
11

12
func TestIsSkippable(t *testing.T) {
13
	t.Parallel()
14

15
	type args struct {
16
		err error
17
	}
18

19
	tests := map[string]struct {
20
		args args
21
		want bool
22
	}{
23
		"skippable": {
24
			args: args{
25
				err: Skippable(Skippable(errTest)),
26
			},
27
			want: true,
28
		},
29
		"unSkippable": {
30
			args: args{
31
				err: errTest,
32
			},
33
			want: false,
34
		},
35
		"nil": {
36
			args: args{
37
				err: nil,
38
			},
39
			want: false,
40
		},
41
	}
42
	for name, tt := range tests {
43
		tt := tt
44
		t.Run(name, func(t *testing.T) {
45
			t.Parallel()
46

47
			got := IsSkippable(tt.args.err)
48

49
			assert.Equal(t, tt.want, got)
50
		})
51
	}
52
}
53

54
func TestSkippable(t *testing.T) {
55
	t.Parallel()
56

57
	type args struct {
58
		err error
59
	}
60

61
	tests := map[string]struct {
62
		args    args
63
		wantErr assert.ErrorAssertionFunc
64
	}{
65
		"skippable": {
66
			args: args{
67
				err: Skippable(Skippable(errTest)),
68
			},
69
			wantErr: func(t assert.TestingT, err error, _ ...interface{}) bool {
70
				return assert.ErrorIs(t, err, ErrSkip) &&
71
					assert.ErrorIs(t, err, errTest)
72
			},
73
		},
74
		"nil": {
75
			args: args{
76
				err: Skippable(Skippable(nil)),
77
			},
78
			wantErr: func(t assert.TestingT, err error, _ ...interface{}) bool {
79
				return assert.Nil(t, err)
80
			},
81
		},
82
	}
83
	for name, tt := range tests {
84
		tt := tt
85
		t.Run(name, func(t *testing.T) {
86
			t.Parallel()
87

88
			err := Skippable(tt.args.err)
89

90
			tt.wantErr(t, err)
91
		})
92
	}
93
}
94

95
func TestUnSkippable(t *testing.T) {
96
	t.Parallel()
97

98
	type args struct {
99
		err error
100
	}
101

102
	tests := map[string]struct {
103
		args    args
104
		wantErr assert.ErrorAssertionFunc
105
	}{
106
		"unSkippable": {
107
			args: args{
108
				err: UnSkippable(UnSkippable(
109
					Skippable(Skippable(errTest)))),
110
			},
111
			wantErr: func(t assert.TestingT, err error, _ ...interface{}) bool {
112
				return assert.NotErrorIs(t, err, ErrSkip) &&
113
					assert.ErrorIs(t, err, errTest)
114
			},
115
		},
116
		"nil": {
117
			args: args{
118
				err: UnSkippable(UnSkippable(nil)),
119
			},
120
			wantErr: func(t assert.TestingT, err error, _ ...interface{}) bool {
121
				return assert.Nil(t, err)
122
			},
123
		},
124
	}
125
	for name, tt := range tests {
126
		tt := tt
127
		t.Run(name, func(t *testing.T) {
128
			t.Parallel()
129

130
			err := UnSkippable(tt.args.err)
131

132
			tt.wantErr(t, err)
133
		})
134
	}
135
}
136