kraken

1
// Copyright (c) 2016-2019 Uber Technologies, Inc.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
package mockutil
15

16
import (
17
	"fmt"
18
	"io/ioutil"
19
	"os"
20
	"testing"
21

22
	"github.com/stretchr/testify/require"
23
)
24

25
func TestMatchReader(t *testing.T) {
26
	tests := []struct {
27
		expected string
28
		actual   string
29
		matches  bool
30
	}{
31
		{"abcd", "abcd", true},
32
		{"abcd", "wxyz", false},
33
		{"", "", true},
34
	}
35
	for _, test := range tests {
36
		t.Run(fmt.Sprintf("%q==%q", test.expected, test.actual), func(t *testing.T) {
37
			require := require.New(t)
38

39
			f, err := ioutil.TempFile("", "")
40
			require.NoError(err)
41
			defer os.Remove(f.Name())
42

43
			_, err = f.Write([]byte(test.actual))
44
			require.NoError(err)
45

46
			// Reset file.
47
			_, err = f.Seek(0, 0)
48
			require.NoError(err)
49

50
			m := MatchReader([]byte(test.expected))
51
			require.Equal(test.matches, m.Matches(f))
52
			require.Equal(test.expected, m.String())
53
		})
54
	}
55
}
56

57
func TestMatchReaderTypeCheck(t *testing.T) {
58
	require := require.New(t)
59

60
	m := MatchReader([]byte("foo"))
61
	require.False(m.Matches(nil))
62
}
63

64
func TestMatchWriter(t *testing.T) {
65
	require := require.New(t)
66

67
	f, err := ioutil.TempFile("", "")
68
	require.NoError(err)
69
	defer os.Remove(f.Name())
70

71
	b := []byte("some text")
72

73
	m := MatchWriter(b)
74
	require.True(m.Matches(f))
75
	require.Equal("WriterMatcher", m.String())
76

77
	// Reset file.
78
	_, err = f.Seek(0, 0)
79
	require.NoError(err)
80

81
	// WriterMatcher should write to the file.
82
	result, err := ioutil.ReadAll(f)
83
	require.Equal(string(b), string(result))
84
}
85

86
func TestMatchWriterTypeCheck(t *testing.T) {
87
	require := require.New(t)
88

89
	m := MatchWriter([]byte("foo"))
90
	require.False(m.Matches(nil))
91
}
92

93
func TestMatchWriterAt(t *testing.T) {
94
	require := require.New(t)
95

96
	f, err := ioutil.TempFile("", "")
97
	require.NoError(err)
98
	defer os.Remove(f.Name())
99

100
	b := []byte("some text")
101

102
	m := MatchWriterAt(b)
103
	require.True(m.Matches(f))
104
	require.Equal("WriterAtMatcher", m.String())
105

106
	// Reset file.
107
	_, err = f.Seek(0, 0)
108
	require.NoError(err)
109

110
	// WriterAtMatcher should write to the file.
111
	result, err := ioutil.ReadAll(f)
112
	require.Equal(string(b), string(result))
113
}
114

115
func TestMatchWriterAtTypeCheck(t *testing.T) {
116
	require := require.New(t)
117

118
	m := MatchWriterAt([]byte("foo"))
119
	require.False(m.Matches(nil))
120
}
121

122
func TestMatchRegex(t *testing.T) {
123
	tests := []struct {
124
		expected string
125
		actual   string
126
		matches  bool
127
	}{
128
		{"foo/.+", "foo/bar", true},
129
		{"foo/.+", "foo/", false},
130
		{"foo", "foo", true},
131
	}
132
	for _, test := range tests {
133
		t.Run(fmt.Sprintf("%q==%q", test.expected, test.actual), func(t *testing.T) {
134
			require := require.New(t)
135

136
			m := MatchRegex(test.expected)
137
			require.Equal(test.matches, m.Matches(test.actual))
138
			require.Equal(test.expected, m.String())
139
		})
140
	}
141
}
142

143
func TestMatchRegexTypeCheck(t *testing.T) {
144
	require := require.New(t)
145

146
	m := MatchRegex("foo")
147
	require.False(m.Matches(nil))
148
}
149