github.com/xmidt-org/webpa-common@v1.11.9/service/servicehttp/hashFilter_test.go (about) 1 package servicehttp 2 3 import ( 4 "context" 5 "errors" 6 "net/http/httptest" 7 "testing" 8 9 "github.com/stretchr/testify/assert" 10 "github.com/stretchr/testify/mock" 11 "github.com/stretchr/testify/require" 12 "github.com/xmidt-org/webpa-common/device" 13 "github.com/xmidt-org/webpa-common/logging" 14 "github.com/xmidt-org/webpa-common/service" 15 ) 16 17 func testNewHashFilterNoAccessor(t *testing.T) { 18 var ( 19 assert = assert.New(t) 20 require = require.New(t) 21 22 self = func(string) bool { 23 assert.Fail("The self predicate should not have been called") 24 return false 25 } 26 27 hf = NewHashFilter(nil, errors.New("reject"), self) 28 ) 29 30 require.NotNil(hf) 31 assert.NoError(hf.Allow(httptest.NewRequest("GET", "/", nil))) 32 } 33 34 func testNewHashFilterNoReject(t *testing.T) { 35 var ( 36 assert = assert.New(t) 37 require = require.New(t) 38 39 a = new(service.MockAccessor) 40 41 self = func(string) bool { 42 assert.Fail("The self predicate should not have been called") 43 return false 44 } 45 46 hf = NewHashFilter(a, nil, self) 47 ) 48 49 require.NotNil(hf) 50 assert.NoError(hf.Allow(httptest.NewRequest("GET", "/", nil))) 51 a.AssertExpectations(t) 52 } 53 54 func testNewHashFilterNoSelf(t *testing.T) { 55 var ( 56 assert = assert.New(t) 57 require = require.New(t) 58 59 a = new(service.MockAccessor) 60 hf = NewHashFilter(a, errors.New("reject"), nil) 61 ) 62 63 require.NotNil(hf) 64 assert.NoError(hf.Allow(httptest.NewRequest("GET", "/", nil))) 65 a.AssertExpectations(t) 66 } 67 68 func testNewHashFilterParseError(t *testing.T) { 69 var ( 70 assert = assert.New(t) 71 require = require.New(t) 72 73 id = "asdlfkj039w485;lkjsd,.fjaw94385" 74 self = func(string) bool { 75 assert.Fail("The self predicate should not have been called") 76 return false 77 } 78 79 accessor = new(service.MockAccessor) 80 hf = NewHashFilter(accessor, errors.New("reject"), self) 81 ) 82 83 require.NotNil(hf) 84 85 request := httptest.NewRequest("GET", "/", nil) 86 request.Header.Set(device.DeviceNameHeader, string(id)) 87 assert.Error(hf.Allow(request)) 88 89 accessor.AssertExpectations(t) 90 } 91 92 func testNewHashFilterHashError(t *testing.T) { 93 var ( 94 assert = assert.New(t) 95 require = require.New(t) 96 97 id = device.IntToMAC(999) 98 self = func(string) bool { 99 assert.Fail("The self predicate should not have been called") 100 return false 101 } 102 103 hashErr = errors.New("hash") 104 accessor = new(service.MockAccessor) 105 hf = NewHashFilter(accessor, errors.New("reject"), self) 106 ) 107 108 require.NotNil(hf) 109 accessor.On("Get", mock.MatchedBy(func([]byte) bool { return true })).Return("", hashErr).Times(2) 110 111 assert.Equal( 112 hashErr, 113 hf.Allow( 114 device.WithIDRequest(id, httptest.NewRequest("GET", "/", nil)), 115 ), 116 ) 117 118 request := httptest.NewRequest("GET", "/", nil) 119 request.Header.Set(device.DeviceNameHeader, string(id)) 120 assert.Equal(hashErr, hf.Allow(request)) 121 122 accessor.AssertExpectations(t) 123 } 124 125 func testNewHashFilterAllow(t *testing.T) { 126 var ( 127 assert = assert.New(t) 128 require = require.New(t) 129 130 id = device.IntToMAC(47283) 131 expectedInstance = "instance" 132 ctx = logging.WithLogger(context.Background(), logging.NewTestLogger(nil, t)) 133 134 selfCalled = false 135 self = func(actualInstance string) bool { 136 selfCalled = true 137 assert.Equal(expectedInstance, actualInstance) 138 return true 139 } 140 141 a = new(service.MockAccessor) 142 hf = NewHashFilter(a, errors.New("reject"), self) 143 ) 144 145 require.NotNil(hf) 146 a.On("Get", mock.MatchedBy(func(k []byte) bool { return string(id) == string(k) })).Return(expectedInstance, error(nil)).Once() 147 148 request := httptest.NewRequest("GET", "/", nil).WithContext(ctx) 149 request.Header.Set(device.DeviceNameHeader, string(id)) 150 assert.NoError(hf.Allow(request)) 151 152 assert.True(selfCalled) 153 a.AssertExpectations(t) 154 } 155 156 func testNewHashFilterReject(t *testing.T) { 157 var ( 158 assert = assert.New(t) 159 require = require.New(t) 160 161 id = device.IntToMAC(93723) 162 expectedInstance = "instance" 163 ctx = logging.WithLogger(context.Background(), logging.NewTestLogger(nil, t)) 164 165 selfCalled = false 166 self = func(actualInstance string) bool { 167 selfCalled = true 168 assert.Equal(expectedInstance, actualInstance) 169 return false 170 } 171 172 a = new(service.MockAccessor) 173 expectedErr = errors.New("expected") 174 hf = NewHashFilter(a, expectedErr, self) 175 ) 176 177 require.NotNil(hf) 178 a.On("Get", mock.MatchedBy(func(k []byte) bool { return string(id) == string(k) })).Return(expectedInstance, error(nil)).Once() 179 180 request := httptest.NewRequest("GET", "/", nil).WithContext(ctx) 181 request.Header.Set(device.DeviceNameHeader, string(id)) 182 assert.Equal(expectedErr, hf.Allow(request)) 183 184 assert.True(selfCalled) 185 a.AssertExpectations(t) 186 } 187 188 func TestNewHashFilter(t *testing.T) { 189 t.Run("NoAccessor", testNewHashFilterNoAccessor) 190 t.Run("NoReject", testNewHashFilterNoReject) 191 t.Run("NoSelf", testNewHashFilterNoSelf) 192 t.Run("ParseError", testNewHashFilterParseError) 193 t.Run("HashError", testNewHashFilterHashError) 194 t.Run("Allow", testNewHashFilterAllow) 195 t.Run("Reject", testNewHashFilterReject) 196 }