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  }