github.com/seeker-insurance/kit@v0.0.13/web/api_context_test.go (about)

     1  package web
     2  
     3  import (
     4  	"net/http"
     5  	"net/url"
     6  	"testing"
     7  
     8  	"github.com/seeker-insurance/kit/errorlib"
     9  
    10  	"github.com/labstack/echo"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  const (
    15  	foo = "foo"
    16  	bar = "bar"
    17  	baz = "baz"
    18  )
    19  
    20  type mockParamsEchoContext struct {
    21  	queryParams map[string]string
    22  	params      map[string]string
    23  	echo.Context
    24  }
    25  
    26  var _ echo.Context = mockParamsEchoContext{}
    27  
    28  func (m mockParamsEchoContext) QueryParams() url.Values {
    29  	out := make(url.Values)
    30  	for k, v := range m.queryParams {
    31  		out[k] = []string{v}
    32  	}
    33  	return out
    34  }
    35  
    36  func (m mockParamsEchoContext) QueryParam(name string) string {
    37  	v, _ := m.queryParams[name]
    38  	return v
    39  }
    40  
    41  func (m mockParamsEchoContext) Param(name string) string {
    42  	v, _ := m.params[name]
    43  	return v
    44  }
    45  
    46  func newMock(queryParams, params map[string]string) ApiContext {
    47  	if queryParams == nil {
    48  		queryParams = make(map[string]string)
    49  	}
    50  	if params == nil {
    51  		params = make(map[string]string)
    52  	}
    53  	return &apiContext{
    54  		Context: mockParamsEchoContext{
    55  			Context:     echo.New().AcquireContext(),
    56  			params:      params,
    57  			queryParams: queryParams,
    58  		},
    59  	}
    60  }
    61  
    62  func Test_apiContext_RequiredQueryParams(t *testing.T) {
    63  	want := map[string]string{
    64  		foo: foo,
    65  		bar: bar,
    66  	}
    67  	ctx := newMock(want, nil)
    68  	got, err := ctx.RequiredQueryParams(foo, bar)
    69  	assert.NoError(t, err)
    70  	assert.Equal(t, want, got)
    71  
    72  	_, err = ctx.RequiredQueryParams(foo, bar, baz)
    73  	assert.Error(t, err)
    74  }
    75  
    76  func Test_apiContext_QParams(t *testing.T) {
    77  	required := []string{foo, bar}
    78  	queryParams := map[string]string{foo: foo, bar: bar, baz: bar}
    79  	ctx := newMock(queryParams, nil)
    80  	got, err := ctx.QParams(required...)
    81  	assert.Equal(t, queryParams, got)
    82  	assert.NoError(t, err)
    83  
    84  	required = []string{"DNE"}
    85  	got, err = ctx.QParams(required...)
    86  	assert.Equal(t, map[string]string(nil), got)
    87  	assert.Error(t, err)
    88  
    89  }
    90  
    91  func Test_apiContext_OptionalQueryParams(t *testing.T) {
    92  	want := map[string]string{
    93  		foo: foo,
    94  		bar: bar,
    95  		baz: "", //deliberately missing
    96  	}
    97  	ctx := newMock(map[string]string{foo: foo, bar: bar}, nil)
    98  	assert.Equal(t, want, ctx.OptionalQueryParams(foo, bar, baz))
    99  }
   100  
   101  func Test_apiContext_BindIdParam(t *testing.T) {
   102  
   103  	var got int
   104  	want := 20
   105  
   106  	ctx := newMock(nil, keyVal("id", "20"))
   107  	assert.NoError(t, ctx.BindIdParam(&got))
   108  	assert.Equal(t, want, got)
   109  
   110  	got, want = 0, 40
   111  	ctx = newMock(nil, keyVal("foobar", "40"))
   112  	assert.NoError(t, ctx.BindIdParam(&got, "foobar"))
   113  
   114  }
   115  
   116  func keyVal(key, val string) map[string]string {
   117  	return map[string]string{key: val}
   118  }
   119  func Test_apiContext_QueryParamTrue(t *testing.T) {
   120  	const foo = foo
   121  
   122  	val, ok := newMock(keyVal(foo, "1"), nil).QueryParamTrue(foo)
   123  	assert.True(t, val)
   124  	assert.True(t, ok)
   125  
   126  	val, ok = newMock(keyVal(foo, "true"), nil).QueryParamTrue(foo)
   127  	assert.True(t, val)
   128  	assert.True(t, ok)
   129  
   130  	val, ok = newMock(keyVal(foo, "0"), nil).QueryParamTrue(foo)
   131  	assert.False(t, val)
   132  	assert.True(t, ok)
   133  
   134  	val, ok = newMock(keyVal(foo, "false"), nil).QueryParamTrue(foo)
   135  	assert.False(t, val)
   136  	assert.True(t, ok)
   137  
   138  	val, ok = newMock(keyVal(foo, "asdaqsd"), nil).QueryParamTrue(foo)
   139  	assert.False(t, val)
   140  	assert.False(t, ok)
   141  }
   142  
   143  func Test_notJsonApi(t *testing.T) {
   144  	assert.True(t, notJsonApi(errorlib.ErrorString("not a jsonapi")))
   145  	assert.True(t, notJsonApi(errorlib.ErrorString("EOF")))
   146  	assert.False(t, notJsonApi(errorlib.ErrorString("foobar")))
   147  }
   148  
   149  func Test_apiContext_ApiError(t *testing.T) {
   150  	want := echo.NewHTTPError(404, "not found")
   151  	ctx := newMock(nil, nil)
   152  	assert.Equal(t, want, ctx.ApiError("not found", 404, 505))
   153  
   154  	want = echo.NewHTTPError(http.StatusBadRequest, "bad request")
   155  	assert.Equal(t, want, ctx.ApiError("bad request"))
   156  }