github.com/xmidt-org/webpa-common@v1.11.9/xhttp/gate/lever_test.go (about)

     1  package gate
     2  
     3  import (
     4  	"context"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"net/url"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/xmidt-org/webpa-common/logging"
    12  )
    13  
    14  func testLeverServeHTTPBadForm(t *testing.T) {
    15  	var (
    16  		assert = assert.New(t)
    17  		logger = logging.NewTestLogger(nil, t)
    18  		ctx    = logging.WithLogger(context.Background(), logger)
    19  
    20  		response = httptest.NewRecorder()
    21  		request  = &http.Request{
    22  			URL: &url.URL{
    23  				RawQuery: `this!is%bad&%TT`,
    24  			},
    25  		}
    26  
    27  		lever = Lever{}
    28  	)
    29  
    30  	lever.ServeHTTP(response, request.WithContext(ctx))
    31  	assert.Equal(http.StatusBadRequest, response.Code)
    32  }
    33  
    34  func testLeverServeHTTPNoParameter(t *testing.T) {
    35  	var (
    36  		assert = assert.New(t)
    37  		logger = logging.NewTestLogger(nil, t)
    38  		ctx    = logging.WithLogger(context.Background(), logger)
    39  
    40  		response = httptest.NewRecorder()
    41  		request  = httptest.NewRequest("POST", "/", nil)
    42  
    43  		lever = Lever{Parameter: "open"}
    44  	)
    45  
    46  	lever.ServeHTTP(response, request.WithContext(ctx))
    47  	assert.Equal(http.StatusBadRequest, response.Code)
    48  }
    49  
    50  func testLeverServeHTTPBadParameter(t *testing.T) {
    51  	var (
    52  		assert = assert.New(t)
    53  		logger = logging.NewTestLogger(nil, t)
    54  		ctx    = logging.WithLogger(context.Background(), logger)
    55  
    56  		response = httptest.NewRecorder()
    57  		request  = httptest.NewRequest("POST", "/foo?open=thisisnotabool", nil)
    58  
    59  		lever = Lever{Parameter: "open"}
    60  	)
    61  
    62  	lever.ServeHTTP(response, request.WithContext(ctx))
    63  	assert.Equal(http.StatusBadRequest, response.Code)
    64  }
    65  
    66  func testLeverServeHTTPRaise(t *testing.T) {
    67  	var (
    68  		assert = assert.New(t)
    69  		logger = logging.NewTestLogger(nil, t)
    70  		ctx    = logging.WithLogger(context.Background(), logger)
    71  
    72  		gate  = New(true)
    73  		lever = Lever{Gate: gate, Parameter: "open"}
    74  	)
    75  
    76  	{
    77  		var (
    78  			response = httptest.NewRecorder()
    79  			request  = httptest.NewRequest("POST", "/foo?open=true", nil)
    80  		)
    81  
    82  		lever.ServeHTTP(response, request.WithContext(ctx))
    83  		assert.Equal(http.StatusOK, response.Code)
    84  		assert.True(gate.Open())
    85  	}
    86  
    87  	{
    88  		var (
    89  			response = httptest.NewRecorder()
    90  			request  = httptest.NewRequest("POST", "/foo?open=false", nil)
    91  		)
    92  
    93  		lever.ServeHTTP(response, request.WithContext(ctx))
    94  		assert.Equal(http.StatusCreated, response.Code)
    95  		assert.False(gate.Open())
    96  	}
    97  
    98  	{
    99  		var (
   100  			response = httptest.NewRecorder()
   101  			request  = httptest.NewRequest("POST", "/foo?open=true", nil)
   102  		)
   103  
   104  		lever.ServeHTTP(response, request.WithContext(ctx))
   105  		assert.Equal(http.StatusCreated, response.Code)
   106  		assert.True(gate.Open())
   107  	}
   108  
   109  	{
   110  		var (
   111  			response = httptest.NewRecorder()
   112  			request  = httptest.NewRequest("POST", "/foo?open=true", nil)
   113  		)
   114  
   115  		lever.ServeHTTP(response, request.WithContext(ctx))
   116  		assert.Equal(http.StatusOK, response.Code)
   117  		assert.True(gate.Open())
   118  	}
   119  }
   120  
   121  func testLeverServeHTTPLower(t *testing.T) {
   122  	var (
   123  		assert = assert.New(t)
   124  		logger = logging.NewTestLogger(nil, t)
   125  		ctx    = logging.WithLogger(context.Background(), logger)
   126  
   127  		gate  = New(false)
   128  		lever = Lever{Gate: gate, Parameter: "open"}
   129  	)
   130  
   131  	{
   132  		var (
   133  			response = httptest.NewRecorder()
   134  			request  = httptest.NewRequest("POST", "/foo?open=false", nil)
   135  		)
   136  
   137  		lever.ServeHTTP(response, request.WithContext(ctx))
   138  		assert.Equal(http.StatusOK, response.Code)
   139  		assert.False(gate.Open())
   140  	}
   141  
   142  	{
   143  		var (
   144  			response = httptest.NewRecorder()
   145  			request  = httptest.NewRequest("POST", "/foo?open=true", nil)
   146  		)
   147  
   148  		lever.ServeHTTP(response, request.WithContext(ctx))
   149  		assert.Equal(http.StatusCreated, response.Code)
   150  		assert.True(gate.Open())
   151  	}
   152  
   153  	{
   154  		var (
   155  			response = httptest.NewRecorder()
   156  			request  = httptest.NewRequest("POST", "/foo?open=false", nil)
   157  		)
   158  
   159  		lever.ServeHTTP(response, request.WithContext(ctx))
   160  		assert.Equal(http.StatusCreated, response.Code)
   161  		assert.False(gate.Open())
   162  	}
   163  
   164  	{
   165  		var (
   166  			response = httptest.NewRecorder()
   167  			request  = httptest.NewRequest("POST", "/foo?open=false", nil)
   168  		)
   169  
   170  		lever.ServeHTTP(response, request.WithContext(ctx))
   171  		assert.Equal(http.StatusOK, response.Code)
   172  		assert.False(gate.Open())
   173  	}
   174  }
   175  
   176  func TestLever(t *testing.T) {
   177  	t.Run("ServeHTTP", func(t *testing.T) {
   178  		t.Run("BadForm", testLeverServeHTTPBadForm)
   179  		t.Run("NoParameter", testLeverServeHTTPNoParameter)
   180  		t.Run("BadParameter", testLeverServeHTTPBadParameter)
   181  		t.Run("Raise", testLeverServeHTTPRaise)
   182  		t.Run("Lower", testLeverServeHTTPLower)
   183  	})
   184  }