time_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  	"encoding/gob"
    20  	"testing"
    21  	"time"
    22  
    23  	"github.com/stretchr/testify/assert"
    24  	"github.com/stretchr/testify/require"
    25  	"go.mongodb.org/mongo-driver/bson"
    26  )
    27  
    28  var (
    29  	p, _ = time.Parse(time.RFC3339Nano, "2011-08-18T19:03:37.000000000+01:00")
    30  
    31  	testCases = []struct {
    32  		in     []byte    // externally sourced data -- to be unmarshalled
    33  		time   time.Time // its representation in time.Time
    34  		str    string    // its marshalled representation
    35  		utcStr string    // the marshaled representation as utc
    36  	}{
    37  		{[]byte("2014-12-15"), time.Date(2014, 12, 15, 0, 0, 0, 0, time.UTC), "2014-12-15T00:00:00.000Z", "2014-12-15T00:00:00.000Z"},
    38  		{[]byte("2014-12-15 08:00:00"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"},
    39  		{[]byte("2014-12-15T08:00:00"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"},
    40  		{[]byte("2014-12-15T08:00"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"},
    41  		{[]byte("2014-12-15T08:00Z"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"},
    42  		{[]byte("2018-01-28T23:54Z"), time.Date(2018, 01, 28, 23, 54, 0, 0, time.UTC), "2018-01-28T23:54:00.000Z", "2018-01-28T23:54:00.000Z"},
    43  		{[]byte("2014-12-15T08:00:00.000Z"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"},
    44  		{[]byte("2011-08-18T19:03:37.123000000+01:00"), time.Date(2011, 8, 18, 19, 3, 37, 123*1e6, p.Location()), "2011-08-18T19:03:37.123+01:00", "2011-08-18T18:03:37.123Z"},
    45  		{[]byte("2011-08-18T19:03:37.123000+0100"), time.Date(2011, 8, 18, 19, 3, 37, 123*1e6, p.Location()), "2011-08-18T19:03:37.123+01:00", "2011-08-18T18:03:37.123Z"},
    46  		{[]byte("2011-08-18T19:03:37.123+0100"), time.Date(2011, 8, 18, 19, 3, 37, 123*1e6, p.Location()), "2011-08-18T19:03:37.123+01:00", "2011-08-18T18:03:37.123Z"},
    47  		{[]byte("2014-12-15T19:30:20Z"), time.Date(2014, 12, 15, 19, 30, 20, 0, time.UTC), "2014-12-15T19:30:20.000Z", "2014-12-15T19:30:20.000Z"},
    48  		{[]byte("0001-01-01T00:00:00Z"), time.Time{}.UTC(), "0001-01-01T00:00:00.000Z", "0001-01-01T00:00:00.000Z"},
    49  		{[]byte(""), time.Unix(0, 0).UTC(), "1970-01-01T00:00:00.000Z", "1970-01-01T00:00:00.000Z"},
    50  		{[]byte(nil), time.Unix(0, 0).UTC(), "1970-01-01T00:00:00.000Z", "1970-01-01T00:00:00.000Z"},
    51  	}
    52  )
    53  
    54  func TestNewDateTime(t *testing.T) {
    55  	assert.EqualValues(t, time.Unix(0, 0).UTC(), NewDateTime())
    56  }
    57  
    58  func TestIsZero(t *testing.T) {
    59  	var empty DateTime
    60  	assert.True(t, empty.IsZero())
    61  	var nilDt *DateTime
    62  	assert.True(t, nilDt.IsZero())
    63  	small := DateTime(time.Unix(100, 5))
    64  	assert.False(t, small.IsZero())
    65  
    66  	// time.Unix(0,0) does not produce a true zero value struct,
    67  	// so this is expected to fail.
    68  	dt := NewDateTime()
    69  	assert.False(t, dt.IsZero())
    70  }
    71  
    72  func TestIsUnixZero(t *testing.T) {
    73  	dt := NewDateTime()
    74  	assert.True(t, dt.IsUnixZero())
    75  	assert.NotEqual(t, dt.IsZero(), dt.IsUnixZero())
    76  	// Test configuring UnixZero
    77  	estLocation := time.FixedZone("EST", int((-5 * time.Hour).Seconds()))
    78  	estUnixZero := time.Unix(0, 0).In(estLocation)
    79  	UnixZero = estUnixZero
    80  	t.Cleanup(func() { UnixZero = time.Unix(0, 0).UTC() })
    81  	dtz := DateTime(estUnixZero)
    82  	assert.True(t, dtz.IsUnixZero())
    83  }
    84  
    85  func TestParseDateTime_errorCases(t *testing.T) {
    86  	_, err := ParseDateTime("yada")
    87  	require.Error(t, err)
    88  }
    89  
    90  // TestParseDateTime tests the full cycle:
    91  // parsing -> marshalling -> unmarshalling / scanning
    92  func TestParseDateTime_fullCycle(t *testing.T) {
    93  	for caseNum, example := range testCases {
    94  		t.Logf("Case #%d", caseNum)
    95  
    96  		parsed, err := ParseDateTime(example.str)
    97  		require.NoError(t, err)
    98  		assert.EqualValues(t, example.time, parsed)
    99  
   100  		mt, err := parsed.MarshalText()
   101  		require.NoError(t, err)
   102  		assert.Equal(t, []byte(example.str), mt)
   103  
   104  		if example.str != "" {
   105  			v := IsDateTime(example.str)
   106  			assert.True(t, v)
   107  		} else {
   108  			t.Logf("IsDateTime() skipped for empty testcases")
   109  		}
   110  
   111  		pp := NewDateTime()
   112  		err = pp.UnmarshalText(mt)
   113  		require.NoError(t, err)
   114  		assert.EqualValues(t, example.time, pp)
   115  
   116  		pp = NewDateTime()
   117  		err = pp.Scan(mt)
   118  		require.NoError(t, err)
   119  		assert.Equal(t, DateTime(example.time), pp)
   120  	}
   121  }
   122  
   123  func TestDateTime_IsDateTime_errorCases(t *testing.T) {
   124  	v := IsDateTime("zor")
   125  	assert.False(t, v)
   126  
   127  	v = IsDateTime("zorg")
   128  	assert.False(t, v)
   129  
   130  	v = IsDateTime("zorgTx")
   131  	assert.False(t, v)
   132  
   133  	v = IsDateTime("1972-12-31Tx")
   134  	assert.False(t, v)
   135  
   136  	v = IsDateTime("1972-12-31T24:40:00.000Z")
   137  	assert.False(t, v)
   138  
   139  	v = IsDateTime("1972-12-31T23:63:00.000Z")
   140  	assert.False(t, v)
   141  
   142  	v = IsDateTime("1972-12-31T23:59:60.000Z")
   143  	assert.False(t, v)
   144  
   145  }
   146  func TestDateTime_UnmarshalText_errorCases(t *testing.T) {
   147  	pp := NewDateTime()
   148  	err := pp.UnmarshalText([]byte("yada"))
   149  	require.Error(t, err)
   150  	err = pp.UnmarshalJSON([]byte("yada"))
   151  	require.Error(t, err)
   152  }
   153  
   154  func TestDateTime_UnmarshalText(t *testing.T) {
   155  	for caseNum, example := range testCases {
   156  		t.Logf("Case #%d", caseNum)
   157  		pp := NewDateTime()
   158  		err := pp.UnmarshalText(example.in)
   159  		require.NoError(t, err)
   160  		assert.EqualValues(t, example.time, pp)
   161  
   162  		// Other way around
   163  		val, erv := pp.Value()
   164  		require.NoError(t, erv)
   165  		assert.EqualValues(t, example.str, val)
   166  
   167  	}
   168  }
   169  func TestDateTime_UnmarshalJSON(t *testing.T) {
   170  	for caseNum, example := range testCases {
   171  		t.Logf("Case #%d", caseNum)
   172  		pp := NewDateTime()
   173  		err := pp.UnmarshalJSON(esc(example.in))
   174  		require.NoError(t, err)
   175  		assert.EqualValues(t, example.time, pp)
   176  	}
   177  
   178  	// Check UnmarshalJSON failure with no lexed items
   179  	pp := NewDateTime()
   180  	err := pp.UnmarshalJSON([]byte("zorg emperor"))
   181  	require.Error(t, err)
   182  
   183  	// Check lexer failure
   184  	err = pp.UnmarshalJSON([]byte(`"zorg emperor"`))
   185  	require.Error(t, err)
   186  
   187  	// Check null case
   188  	err = pp.UnmarshalJSON([]byte("null"))
   189  	require.NoError(t, err)
   190  }
   191  
   192  func esc(v []byte) []byte {
   193  	var buf bytes.Buffer
   194  	buf.WriteByte('"')
   195  	buf.Write(v)
   196  	buf.WriteByte('"')
   197  	return buf.Bytes()
   198  }
   199  
   200  func TestDateTime_MarshalText(t *testing.T) {
   201  	for caseNum, example := range testCases {
   202  		t.Logf("Case #%d", caseNum)
   203  		dt := DateTime(example.time)
   204  		mt, err := dt.MarshalText()
   205  		require.NoError(t, err)
   206  		assert.Equal(t, []byte(example.str), mt)
   207  	}
   208  }
   209  func TestDateTime_MarshalJSON(t *testing.T) {
   210  	for caseNum, example := range testCases {
   211  		t.Logf("Case #%d", caseNum)
   212  		dt := DateTime(example.time)
   213  		bb, err := dt.MarshalJSON()
   214  		require.NoError(t, err)
   215  		assert.EqualValues(t, esc([]byte(example.str)), bb)
   216  	}
   217  }
   218  func TestDateTime_MarshalJSON_Override(t *testing.T) {
   219  	oldNormalizeMarshal := NormalizeTimeForMarshal
   220  	defer func() {
   221  		NormalizeTimeForMarshal = oldNormalizeMarshal
   222  	}()
   223  
   224  	NormalizeTimeForMarshal = func(t time.Time) time.Time {
   225  		return t.UTC()
   226  	}
   227  	for caseNum, example := range testCases {
   228  		t.Logf("Case #%d", caseNum)
   229  		dt := DateTime(example.time.UTC())
   230  		bb, err := dt.MarshalJSON()
   231  		require.NoError(t, err)
   232  		assert.EqualValues(t, esc([]byte(example.utcStr)), bb)
   233  	}
   234  }
   235  
   236  func TestDateTime_Scan(t *testing.T) {
   237  	for caseNum, example := range testCases {
   238  		t.Logf("Case #%d", caseNum)
   239  
   240  		pp := NewDateTime()
   241  		err := pp.Scan(example.in)
   242  		require.NoError(t, err)
   243  		assert.Equal(t, DateTime(example.time), pp)
   244  
   245  		pp = NewDateTime()
   246  		err = pp.Scan(string(example.in))
   247  		require.NoError(t, err)
   248  		assert.Equal(t, DateTime(example.time), pp)
   249  
   250  		pp = NewDateTime()
   251  		err = pp.Scan(example.time)
   252  		require.NoError(t, err)
   253  		assert.Equal(t, DateTime(example.time), pp)
   254  	}
   255  }
   256  
   257  func TestDateTime_Scan_Failed(t *testing.T) {
   258  	pp := NewDateTime()
   259  	zero := NewDateTime()
   260  
   261  	err := pp.Scan(nil)
   262  	require.NoError(t, err)
   263  	// Zero values differ...
   264  	// assert.Equal(t, zero, pp)
   265  	assert.Equal(t, DateTime{}, pp)
   266  
   267  	err = pp.Scan("")
   268  	require.NoError(t, err)
   269  	assert.Equal(t, zero, pp)
   270  
   271  	err = pp.Scan(int64(0))
   272  	require.Error(t, err)
   273  
   274  	err = pp.Scan(float64(0))
   275  	require.Error(t, err)
   276  }
   277  
   278  func TestDateTime_BSON(t *testing.T) {
   279  	for caseNum, example := range testCases {
   280  		t.Logf("Case #%d", caseNum)
   281  		dt := DateTime(example.time)
   282  
   283  		bsonData, err := bson.Marshal(&dt)
   284  		require.NoError(t, err)
   285  
   286  		var dtCopy DateTime
   287  		err = bson.Unmarshal(bsonData, &dtCopy)
   288  		require.NoError(t, err)
   289  		// BSON DateTime type loses timezone information, so compare UTC()
   290  		assert.Equal(t, time.Time(dt).UTC(), time.Time(dtCopy).UTC())
   291  
   292  		// Check value marshaling explicitly
   293  		m := bson.M{"data": dt}
   294  		bsonData, err = bson.Marshal(&m)
   295  		require.NoError(t, err)
   296  
   297  		var mCopy bson.M
   298  		err = bson.Unmarshal(bsonData, &mCopy)
   299  		require.NoError(t, err)
   300  
   301  		data, ok := m["data"].(DateTime)
   302  		assert.True(t, ok)
   303  		assert.Equal(t, time.Time(dt).UTC(), time.Time(data).UTC())
   304  	}
   305  }
   306  
   307  func TestDeepCopyDateTime(t *testing.T) {
   308  	p, err := ParseDateTime("2011-08-18T19:03:37.000000000+01:00")
   309  	require.NoError(t, err)
   310  	in := &p
   311  
   312  	out := new(DateTime)
   313  	in.DeepCopyInto(out)
   314  	assert.Equal(t, in, out)
   315  
   316  	out2 := in.DeepCopy()
   317  	assert.Equal(t, in, out2)
   318  
   319  	var inNil *DateTime
   320  	out3 := inNil.DeepCopy()
   321  	assert.Nil(t, out3)
   322  }
   323  
   324  func TestGobEncodingDateTime(t *testing.T) {
   325  	now := time.Now()
   326  
   327  	b := bytes.Buffer{}
   328  	enc := gob.NewEncoder(&b)
   329  	err := enc.Encode(DateTime(now))
   330  	require.NoError(t, err)
   331  	assert.NotEmpty(t, b.Bytes())
   332  
   333  	var result DateTime
   334  
   335  	dec := gob.NewDecoder(&b)
   336  	err = dec.Decode(&result)
   337  	require.NoError(t, err)
   338  	assert.Equal(t, now.Year(), time.Time(result).Year())
   339  	assert.Equal(t, now.Month(), time.Time(result).Month())
   340  	assert.Equal(t, now.Day(), time.Time(result).Day())
   341  	assert.Equal(t, now.Hour(), time.Time(result).Hour())
   342  	assert.Equal(t, now.Minute(), time.Time(result).Minute())
   343  	assert.Equal(t, now.Second(), time.Time(result).Second())
   344  }
   345  
   346  func TestDateTime_Equal(t *testing.T) {
   347  	t.Parallel()
   348  
   349  	dt1 := DateTime(time.Now())
   350  	dt2 := DateTime(time.Time(dt1).Add(time.Second))
   351  
   352  	//nolint:gocritic
   353  	assert.True(t, dt1.Equal(dt1), "DateTime instances should be equal")
   354  	assert.False(t, dt1.Equal(dt2), "DateTime instances should not be equal")
   355  }
   356
View as plain text