github.com/uber/kraken@v0.1.4/utils/mockutil/mockutil_test.go (about)

     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  }