date_test.go

Documentation: github.com/go-openapi/strfmt

     1  // Copyright 2015 go-swagger maintainers
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //    http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package strfmt
    16  
    17  import (
    18  	"bytes"
    19  	"database/sql"
    20  	"database/sql/driver"
    21  	"encoding/gob"
    22  	"testing"
    23  	"time"
    24  
    25  	"github.com/stretchr/testify/assert"
    26  	"github.com/stretchr/testify/require"
    27  	"go.mongodb.org/mongo-driver/bson"
    28  )
    29  
    30  var _ sql.Scanner = &Date{}
    31  var _ driver.Valuer = Date{}
    32  
    33  func TestDate(t *testing.T) {
    34  	pp := Date{}
    35  	err := pp.UnmarshalText([]byte{})
    36  	require.NoError(t, err)
    37  	err = pp.UnmarshalText([]byte("yada"))
    38  	require.Error(t, err)
    39  
    40  	orig := "2014-12-15"
    41  	bj := []byte("\"" + orig + "\"")
    42  	err = pp.UnmarshalText([]byte(orig))
    43  	require.NoError(t, err)
    44  
    45  	txt, err := pp.MarshalText()
    46  	require.NoError(t, err)
    47  	assert.Equal(t, orig, string(txt))
    48  
    49  	err = pp.UnmarshalJSON(bj)
    50  	require.NoError(t, err)
    51  	assert.EqualValues(t, orig, pp.String())
    52  
    53  	err = pp.UnmarshalJSON([]byte(`"1972/01/01"`))
    54  	require.Error(t, err)
    55  
    56  	b, err := pp.MarshalJSON()
    57  	require.NoError(t, err)
    58  	assert.Equal(t, bj, b)
    59  
    60  	dateOriginal := Date(time.Date(2014, 10, 10, 0, 0, 0, 0, time.UTC))
    61  
    62  	bsonData, err := bson.Marshal(&dateOriginal)
    63  	require.NoError(t, err)
    64  
    65  	var dateCopy Date
    66  	err = bson.Unmarshal(bsonData, &dateCopy)
    67  	require.NoError(t, err)
    68  	assert.Equal(t, dateOriginal, dateCopy)
    69  
    70  	var dateZero Date
    71  	err = dateZero.UnmarshalJSON([]byte(jsonNull))
    72  	require.NoError(t, err)
    73  	assert.Equal(t, Date{}, dateZero)
    74  }
    75  
    76  func TestDate_Scan(t *testing.T) {
    77  	ref := time.Now().Truncate(24 * time.Hour).UTC()
    78  	date, str := Date(ref), ref.Format(RFC3339FullDate)
    79  
    80  	values := []interface{}{str, []byte(str), ref}
    81  	for _, value := range values {
    82  		result := Date{}
    83  		_ = (&result).Scan(value)
    84  		assert.Equal(t, date, result, "value: %#v", value)
    85  	}
    86  
    87  	dd := Date{}
    88  	err := dd.Scan(nil)
    89  	require.NoError(t, err)
    90  	assert.Equal(t, Date{}, dd)
    91  
    92  	err = dd.Scan(19700101)
    93  	require.Error(t, err)
    94  }
    95  
    96  func TestDate_Value(t *testing.T) {
    97  	ref := time.Now().Truncate(24 * time.Hour).UTC()
    98  	date := Date(ref)
    99  	dbv, err := date.Value()
   100  	require.NoError(t, err)
   101  	assert.EqualValues(t, dbv, ref.Format("2006-01-02"))
   102  }
   103  
   104  func TestDate_IsDate(t *testing.T) {
   105  	tests := []struct {
   106  		value string
   107  		valid bool
   108  	}{
   109  		{"2017-12-22", true},
   110  		{"2017-1-1", false},
   111  		{"17-13-22", false},
   112  		{"2017-02-29", false}, // not a valid date : 2017 is not a leap year
   113  		{"1900-02-29", false}, // not a valid date : 1900 is not a leap year
   114  		{"2100-02-29", false}, // not a valid date : 2100 is not a leap year
   115  		{"2000-02-29", true},  // a valid date : 2000 is a leap year
   116  		{"2400-02-29", true},  // a valid date : 2000 is a leap year
   117  		{"2017-13-22", false},
   118  		{"2017-12-32", false},
   119  		{"20171-12-32", false},
   120  		{"YYYY-MM-DD", false},
   121  		{"20-17-2017", false},
   122  		{"2017-12-22T01:02:03Z", false},
   123  	}
   124  	for _, test := range tests {
   125  		assert.Equal(t, test.valid, IsDate(test.value), "value [%s] should be valid: [%t]", test.value, test.valid)
   126  	}
   127  }
   128  
   129  func TestDeepCopyDate(t *testing.T) {
   130  	ref := time.Now().Truncate(24 * time.Hour).UTC()
   131  	date := Date(ref)
   132  	in := &date
   133  
   134  	out := new(Date)
   135  	in.DeepCopyInto(out)
   136  	assert.Equal(t, in, out)
   137  
   138  	out2 := in.DeepCopy()
   139  	assert.Equal(t, in, out2)
   140  
   141  	var inNil *Date
   142  	out3 := inNil.DeepCopy()
   143  	assert.Nil(t, out3)
   144  }
   145  
   146  func TestGobEncodingDate(t *testing.T) {
   147  	now := time.Now()
   148  
   149  	b := bytes.Buffer{}
   150  	enc := gob.NewEncoder(&b)
   151  	err := enc.Encode(Date(now))
   152  	require.NoError(t, err)
   153  	assert.NotEmpty(t, b.Bytes())
   154  
   155  	var result Date
   156  
   157  	dec := gob.NewDecoder(&b)
   158  	err = dec.Decode(&result)
   159  	require.NoError(t, err)
   160  	assert.Equal(t, now.Year(), time.Time(result).Year())
   161  	assert.Equal(t, now.Month(), time.Time(result).Month())
   162  	assert.Equal(t, now.Day(), time.Time(result).Day())
   163  }
   164  
   165  func TestDate_Equal(t *testing.T) {
   166  	t.Parallel()
   167  
   168  	d1 := Date(time.Date(2020, 10, 11, 12, 13, 14, 15, time.UTC))
   169  	d2 := Date(time.Date(2020, 10, 11, 12, 13, 14, 15, time.UTC))
   170  	d3 := Date(time.Date(2020, 11, 12, 13, 14, 15, 16, time.UTC))
   171  
   172  	//nolint:gocritic
   173  	assert.True(t, d1.Equal(d1), "Same Date should Equal itself")
   174  	assert.True(t, d1.Equal(d2), "Date instances should be equal")
   175  	assert.False(t, d1.Equal(d3), "Date instances should not be equal")
   176  }
   177
View as plain text