go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/web/value_test.go (about)

     1  /*
     2  
     3  Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
     4  Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.
     5  
     6  */
     7  
     8  package web
     9  
    10  import (
    11  	"net/http"
    12  	"net/url"
    13  	"testing"
    14  	"time"
    15  
    16  	. "go.charczuk.com/sdk/assert"
    17  	"go.charczuk.com/sdk/uuid"
    18  )
    19  
    20  func Test_RouteValue(t *testing.T) {
    21  	ctx := &baseContext{
    22  		routeParams: RouteParameters{
    23  			{Key: "foo", Value: "foo-value"},
    24  			{Key: "bar", Value: "123"},
    25  		},
    26  	}
    27  
    28  	missing, err := RouteValue[string](ctx, "not-foo")
    29  	ItsNotNil(t, err)
    30  	ItsEqual(t, "required route parameter missing; not-foo", err.Error())
    31  	ItsEmpty(t, missing)
    32  
    33  	present, err := RouteValue[string](ctx, "foo")
    34  	ItsNil(t, err)
    35  	ItsEqual(t, "foo-value", present)
    36  
    37  	parsed, err := RouteValue[int](ctx, "bar")
    38  	ItsNil(t, err)
    39  	ItsEqual(t, 123, parsed)
    40  
    41  	notParsed, err := RouteValue[time.Time](ctx, "bar")
    42  	ItsNotNil(t, err)
    43  	ItsEqual(t, true, notParsed.IsZero())
    44  }
    45  
    46  func Test_QueryValue(t *testing.T) {
    47  	rawQuery := url.Values{
    48  		"foo": []string{"foo-value"},
    49  		"bar": []string{"123"},
    50  	}
    51  	ctx := &baseContext{
    52  		req: &http.Request{
    53  			URL: &url.URL{
    54  				RawQuery: rawQuery.Encode(),
    55  			},
    56  		},
    57  	}
    58  
    59  	missing, err := QueryValue[string](ctx, "not-foo")
    60  	ItsNotNil(t, err)
    61  	ItsEqual(t, "required query value missing; not-foo", err.Error())
    62  	ItsEmpty(t, missing)
    63  
    64  	present, err := QueryValue[string](ctx, "foo")
    65  	ItsNil(t, err)
    66  	ItsEqual(t, "foo-value", present)
    67  
    68  	parsed, err := QueryValue[int](ctx, "bar")
    69  	ItsNil(t, err)
    70  	ItsEqual(t, 123, parsed)
    71  
    72  	notParsed, err := QueryValue[time.Time](ctx, "bar")
    73  	ItsNotNil(t, err)
    74  	ItsEqual(t, true, notParsed.IsZero())
    75  }
    76  
    77  func Test_HeaderValue(t *testing.T) {
    78  	rawHeader := http.Header{
    79  		"Foo": []string{"foo-value"},
    80  		"Bar": []string{"123"},
    81  	}
    82  	ctx := &baseContext{
    83  		req: &http.Request{
    84  			Header: rawHeader,
    85  		},
    86  	}
    87  
    88  	missing, err := HeaderValue[string](ctx, "not-foo")
    89  	ItsNotNil(t, err)
    90  	ItsEqual(t, "required header value missing; not-foo", err.Error())
    91  	ItsEmpty(t, missing)
    92  
    93  	present, err := HeaderValue[string](ctx, "Foo")
    94  	ItsNil(t, err)
    95  	ItsEqual(t, "foo-value", present)
    96  
    97  	parsed, err := HeaderValue[int](ctx, "Bar")
    98  	ItsNil(t, err)
    99  	ItsEqual(t, 123, parsed)
   100  
   101  	notParsed, err := HeaderValue[time.Time](ctx, "Bar")
   102  	ItsNotNil(t, err)
   103  	ItsEqual(t, true, notParsed.IsZero())
   104  }
   105  
   106  func Test_FormValue(t *testing.T) {
   107  	rawForm := url.Values{
   108  		"foo": []string{"foo-value"},
   109  		"bar": []string{"123"},
   110  	}
   111  	ctx := &baseContext{
   112  		req: &http.Request{
   113  			PostForm: rawForm,
   114  		},
   115  	}
   116  
   117  	missing, err := FormValue[string](ctx, "not-foo")
   118  	ItsNotNil(t, err)
   119  	ItsEqual(t, "required post form value missing; not-foo", err.Error())
   120  	ItsEmpty(t, missing)
   121  
   122  	present, err := FormValue[string](ctx, "foo")
   123  	ItsNil(t, err)
   124  	ItsEqual(t, "foo-value", present)
   125  
   126  	parsed, err := FormValue[int](ctx, "bar")
   127  	ItsNil(t, err)
   128  	ItsEqual(t, 123, parsed)
   129  
   130  	notParsed, err := FormValue[time.Time](ctx, "bar")
   131  	ItsNotNil(t, err)
   132  	ItsEqual(t, true, notParsed.IsZero())
   133  }
   134  
   135  func Test_Value_ParseValue_string(t *testing.T) {
   136  	var obj string
   137  	err := ParseValue(&obj, "foo")
   138  	ItsNil(t, err)
   139  	ItsEqual(t, "foo", obj)
   140  }
   141  
   142  func Test_Value_ParseValue_bool(t *testing.T) {
   143  	var obj bool
   144  	err := ParseValue(&obj, "true")
   145  	ItsNil(t, err)
   146  	ItsEqual(t, true, obj)
   147  
   148  	err = ParseValue(&obj, "false")
   149  	ItsNil(t, err)
   150  	ItsEqual(t, false, obj)
   151  
   152  	err = ParseValue(&obj, "foo")
   153  	ItsNotNil(t, err)
   154  }
   155  
   156  func Test_Value_ParseValue_int(t *testing.T) {
   157  	var obj int
   158  	err := ParseValue(&obj, "1234")
   159  	ItsNil(t, err)
   160  	ItsEqual(t, 1234, obj)
   161  
   162  	err = ParseValue(&obj, "foo")
   163  	ItsNotNil(t, err)
   164  }
   165  
   166  func Test_Value_ParseValue_int64(t *testing.T) {
   167  	var obj int64
   168  	err := ParseValue(&obj, "1234")
   169  	ItsNil(t, err)
   170  	ItsEqual(t, 1234, obj)
   171  
   172  	err = ParseValue(&obj, "foo")
   173  	ItsNotNil(t, err)
   174  }
   175  
   176  func Test_Value_ParseValue_float32(t *testing.T) {
   177  	var obj float32
   178  	err := ParseValue(&obj, "1234.23")
   179  	ItsNil(t, err)
   180  	ItsEqual(t, 1234.23, obj)
   181  
   182  	err = ParseValue(&obj, "foo")
   183  	ItsNotNil(t, err)
   184  }
   185  
   186  func Test_Value_ParseValue_float64(t *testing.T) {
   187  	var obj float64
   188  	err := ParseValue(&obj, "1234.23")
   189  	ItsNil(t, err)
   190  	ItsEqual(t, 1234.23, obj)
   191  
   192  	err = ParseValue(&obj, "foo")
   193  	ItsNotNil(t, err)
   194  }
   195  
   196  func Test_Value_ParseValue_Duration(t *testing.T) {
   197  	var obj time.Duration
   198  	err := ParseValue(&obj, "500ms")
   199  	ItsNil(t, err)
   200  	ItsEqual(t, 500*time.Millisecond, obj)
   201  
   202  	err = ParseValue(&obj, "foo")
   203  	ItsNotNil(t, err)
   204  }
   205  
   206  func Test_Value_ParseValue_UUID(t *testing.T) {
   207  	expected := uuid.V4()
   208  	var obj uuid.UUID
   209  	err := ParseValue(&obj, expected.String())
   210  	ItsNil(t, err)
   211  	ItsEqual(t, expected.String(), obj.String())
   212  
   213  	err = ParseValue(&obj, "foo")
   214  	ItsNotNil(t, err)
   215  }
   216  
   217  func Test_Value_ParseValue_Invalid(t *testing.T) {
   218  	var obj struct{}
   219  	err := ParseValue(&obj, "hello")
   220  	ItsNotNil(t, err)
   221  }