github.com/xmidt-org/webpa-common@v1.11.9/device/dialer_test.go (about)

     1  package device
     2  
     3  import (
     4  	"errors"
     5  	"net/http"
     6  	"testing"
     7  
     8  	"github.com/gorilla/websocket"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func testDialerDefault(t *testing.T) {
    14  	var (
    15  		assert  = assert.New(t)
    16  		require = require.New(t)
    17  
    18  		result = NewDialer(DialerOptions{})
    19  	)
    20  
    21  	require.NotNil(result)
    22  	d, ok := result.(*dialer)
    23  	require.True(ok)
    24  
    25  	assert.Equal(DeviceNameHeader, d.deviceHeader)
    26  	assert.Equal(defaultWebsocketDialer, d.wd)
    27  }
    28  
    29  func testDialerDialDevice(t *testing.T, deviceName, expectedURL, deviceHeader string, extra, expectedHeader http.Header) {
    30  	var (
    31  		assert  = assert.New(t)
    32  		require = require.New(t)
    33  
    34  		expectedConn     = new(websocket.Conn)
    35  		expectedResponse = new(http.Response)
    36  
    37  		websocketDialer = new(mockWebsocketDialer)
    38  		dialer          = NewDialer(DialerOptions{DeviceHeader: deviceHeader, WSDialer: websocketDialer})
    39  	)
    40  
    41  	require.NotNil(dialer)
    42  
    43  	websocketDialer.On("Dial", expectedURL, expectedHeader).
    44  		Return(expectedConn, expectedResponse, nil).
    45  		Once()
    46  
    47  	actualConn, actualResponse, actualErr := dialer.DialDevice(deviceName, expectedURL, extra)
    48  	assert.True(expectedConn == actualConn)
    49  	assert.True(expectedResponse == actualResponse)
    50  	assert.Nil(actualErr)
    51  
    52  	websocketDialer.AssertExpectations(t)
    53  }
    54  
    55  func TestDialer(t *testing.T) {
    56  	t.Run("Default", testDialerDefault)
    57  
    58  	const (
    59  		deviceName  = "mac:112233445566/service"
    60  		expectedURL = "http://somewhere.foobar.com/api/blah/blah"
    61  	)
    62  
    63  	t.Run("DialDevice", func(t *testing.T) {
    64  		testDialerDialDevice(t, deviceName, expectedURL, "", nil, http.Header{DeviceNameHeader: {deviceName}})
    65  		testDialerDialDevice(t, deviceName, expectedURL, "X-Something", http.Header{"Content-Type": {"text/plain"}}, http.Header{"Content-Type": {"text/plain"}, "X-Something": {deviceName}})
    66  	})
    67  }
    68  
    69  func testMustDialDeviceSuccess(t *testing.T, deviceName, url string, extra http.Header) {
    70  	var (
    71  		assert           = assert.New(t)
    72  		expectedConn     = new(websocket.Conn)
    73  		expectedResponse = new(http.Response)
    74  
    75  		dialer = new(mockDialer)
    76  	)
    77  
    78  	dialer.On("DialDevice", deviceName, url, extra).
    79  		Return(expectedConn, expectedResponse, nil).
    80  		Once()
    81  
    82  	assert.NotPanics(func() {
    83  		actualConn, actualResponse := MustDialDevice(dialer, deviceName, url, extra)
    84  		assert.True(expectedConn == actualConn)
    85  		assert.True(expectedResponse == actualResponse)
    86  	})
    87  
    88  	dialer.AssertExpectations(t)
    89  }
    90  
    91  func testMustDialDeviceFailure(t *testing.T, deviceName, url string, extra http.Header) {
    92  	var (
    93  		assert        = assert.New(t)
    94  		expectedError = errors.New("expected panic")
    95  
    96  		dialer = new(mockDialer)
    97  	)
    98  
    99  	dialer.On("DialDevice", deviceName, url, extra).
   100  		Return(nil, nil, expectedError).
   101  		Once()
   102  
   103  	assert.Panics(func() {
   104  		MustDialDevice(dialer, deviceName, url, extra)
   105  	})
   106  
   107  	dialer.AssertExpectations(t)
   108  }
   109  
   110  func TestMustDialDevice(t *testing.T) {
   111  	const (
   112  		deviceName  = "mac:112233445566/service"
   113  		expectedURL = "http://somewhere.foobar.com/api/blah/blah"
   114  	)
   115  
   116  	t.Run("Success", func(t *testing.T) {
   117  		testMustDialDeviceSuccess(t, deviceName, expectedURL, nil)
   118  		testMustDialDeviceSuccess(t, deviceName, expectedURL, http.Header{"Content-Type": {"text/plain"}, "X-Something": {"value1", "value2"}})
   119  	})
   120  
   121  	t.Run("Failure", func(t *testing.T) {
   122  		testMustDialDeviceFailure(t, deviceName, expectedURL, nil)
   123  		testMustDialDeviceFailure(t, deviceName, expectedURL, http.Header{"Content-Type": {"text/plain"}, "X-Something": {"value1", "value2"}})
   124  	})
   125  }