github.com/polygon-io/client-go@v1.16.4/rest/encoder/encoder_test.go (about)

     1  package encoder_test
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/polygon-io/client-go/rest/encoder"
     8  	"github.com/polygon-io/client-go/rest/models"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestEncodeParams(t *testing.T) {
    13  	testPath := "/v1/{num}/{str}"
    14  
    15  	type Params struct {
    16  		Num float64 `validate:"required" path:"num"`
    17  		Str string  `validate:"required" path:"str"`
    18  
    19  		NumQ *float64 `query:"num"`
    20  		StrQ *string  `query:"str"`
    21  	}
    22  
    23  	num := 1.6302
    24  	str := "testing"
    25  	params := Params{
    26  		Num:  1.6302,
    27  		Str:  str,
    28  		NumQ: &num,
    29  		StrQ: &str,
    30  	}
    31  
    32  	expected := "/v1/1.6302/testing?num=1.6302&str=testing"
    33  	actual, err := encoder.New().EncodeParams(testPath, params)
    34  	assert.Nil(t, err)
    35  	assert.Equal(t, expected, actual)
    36  }
    37  
    38  func TestEncodeTime(t *testing.T) {
    39  	testPath := "/v1/{time}"
    40  
    41  	type Params struct {
    42  		Time  models.Time  `validate:"required" path:"time"`
    43  		TimeQ *models.Time `query:"time"`
    44  	}
    45  
    46  	ptime := models.Time(time.Date(2021, 7, 22, 0, 0, 0, 0, time.UTC))
    47  	params := Params{
    48  		Time:  ptime,
    49  		TimeQ: &ptime,
    50  	}
    51  
    52  	expected := "/v1/2021-07-22T00:00:00.000Z?time=2021-07-22T00%3A00%3A00.000Z"
    53  	actual, err := encoder.New().EncodeParams(testPath, params)
    54  	assert.Nil(t, err)
    55  	assert.Equal(t, expected, actual)
    56  }
    57  
    58  func TestEncodeDate(t *testing.T) {
    59  	testPath := "/v1/{date}"
    60  
    61  	type Params struct {
    62  		Date  models.Date  `validate:"required" path:"date"`
    63  		DateQ *models.Date `query:"date"`
    64  	}
    65  
    66  	pdate := models.Date(time.Date(2021, 7, 22, 0, 0, 0, 0, time.UTC))
    67  	params := Params{
    68  		Date:  pdate,
    69  		DateQ: &pdate,
    70  	}
    71  
    72  	expected := "/v1/2021-07-22?date=2021-07-22"
    73  	actual, err := encoder.New().EncodeParams(testPath, params)
    74  	assert.Nil(t, err)
    75  	assert.Equal(t, expected, actual)
    76  }
    77  
    78  func TestEncodeMillis(t *testing.T) {
    79  	testPath := "/v1/{millis}"
    80  
    81  	type Params struct {
    82  		Millis  models.Millis  `validate:"required" path:"millis"`
    83  		MillisQ *models.Millis `query:"millis"`
    84  	}
    85  
    86  	pmillis := models.Millis(time.Date(2021, 7, 22, 0, 0, 0, 0, time.UTC))
    87  	params := Params{
    88  		Millis:  pmillis,
    89  		MillisQ: &pmillis,
    90  	}
    91  
    92  	expected := "/v1/1626912000000?millis=1626912000000"
    93  	actual, err := encoder.New().EncodeParams(testPath, params)
    94  	assert.Nil(t, err)
    95  	assert.Equal(t, expected, actual)
    96  }
    97  
    98  func TestEncodeNanos(t *testing.T) {
    99  	testPath := "/v1/{nanos}"
   100  
   101  	type Params struct {
   102  		Nanos  models.Nanos  `validate:"required" path:"nanos"`
   103  		NanosQ *models.Nanos `query:"nanos"`
   104  	}
   105  
   106  	pnanos := models.Nanos(time.Date(2021, 7, 22, 10, 0, 0, 0, time.UTC))
   107  	params := Params{
   108  		Nanos:  pnanos,
   109  		NanosQ: &pnanos,
   110  	}
   111  
   112  	expected := "/v1/1626948000000000000?nanos=1626948000000000000"
   113  	actual, err := encoder.New().EncodeParams(testPath, params)
   114  	assert.Nil(t, err)
   115  	assert.Equal(t, expected, actual)
   116  }
   117  
   118  func TestEncodeDayNanos(t *testing.T) {
   119  	testPath := "/v1/{nanos}"
   120  
   121  	type Params struct {
   122  		Nanos  models.Nanos  `validate:"required" path:"nanos"`
   123  		NanosQ *models.Nanos `query:"nanos"`
   124  	}
   125  
   126  	pnanos := models.Nanos(time.Date(2021, 7, 22, 0, 0, 0, 0, time.UTC))
   127  	params := Params{
   128  		Nanos:  pnanos,
   129  		NanosQ: &pnanos,
   130  	}
   131  
   132  	expected := "/v1/2021-07-22?nanos=2021-07-22"
   133  	actual, err := encoder.New().EncodeParams(testPath, params)
   134  	assert.Nil(t, err)
   135  	assert.Equal(t, expected, actual)
   136  }
   137  
   138  func TestValidateError(t *testing.T) {
   139  	_, err := encoder.New().EncodeParams("/v1/test", nil)
   140  	assert.NotNil(t, err)
   141  }