Move timestamp to time.Time

storage/contact.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
 package storage
 
 import (
@@ -30,20 +36,14 @@ func (s *Session) GetContact(name string) (*Contact, error) {
 }
 
 func (s *Session) SetContact(name string, record *Contact) error {
-	now, err := time.Now().MarshalText()
-	if err != nil {
-		return err
-	}
-
 	key := MakeKeyPrefix("Contact", currentContactVersion) + name
-	var data []byte
-	data, err = json.Marshal(record)
+	data, err := json.Marshal(record)
 	if err != nil {
 		return err
 	}
 	obj := VersionedObject{
 		Version:   currentContactVersion,
-		Timestamp: now,
+		Timestamp: time.Now(),
 		Data:      data,
 	}
 	return s.Set(key, &obj)

storage/contact_test.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
 package storage
 
 import (

storage/session.go

@@ -52,12 +52,8 @@ func (s *Session) GetLastMessageId() (string, error) {
 
 // Set the LastMessageID in the Session
 func (s *Session) SetLastMessageId(id string) error {
-	ts, err := time.Now().MarshalText()
-	if err != nil {
-		return err
-	}
 	vo := &VersionedObject{
-		Timestamp: ts,
+		Timestamp: time.Now(),
 		Data:      []byte(id),
 	}
 	return s.kv.Set("LastMessageID", vo)

storage/session_test.go

@@ -25,13 +25,9 @@ func TestSession_Smoke(t *testing.T) {
 		t.Errorf("failed to init: %+v", err)
 	}
 
-	ts, err := time.Now().MarshalText()
-	if err != nil {
-		t.Errorf("Failed to martial time for object")
-	}
 	err = s.Set("testkey", &VersionedObject{
 		Version:   0,
-		Timestamp: ts,
+		Timestamp: time.Now(),
 		Data:      []byte("test"),
 	})
 	if err != nil {

storage/versionedkv.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
 package storage
 
 import (
@@ -6,6 +12,7 @@ import (
 	"gitlab.com/elixxir/ekv"
 	"strconv"
 	"strings"
+	"time"
 )
 
 // MakeKeyPrefix provides a helper with a data type and a version
@@ -24,9 +31,8 @@ type VersionedObject struct {
 	// Used to determine version upgrade, if any
 	Version uint64
 
-	// Marshal to/from time.Time using Time.MarshalText and
-	// Time.UnmarshalText
-	Timestamp []byte
+	// Set when this object is written
+	Timestamp time.Time
 
 	// Serialized version of original object
 	Data []byte

storage/versionedkv_test.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
 package storage
 
 import (
@@ -10,22 +16,16 @@ import (
 
 // Shows that all fields can be serialized/deserialized correctly using json
 func TestVersionedObject_MarshalUnmarshal(t *testing.T) {
-	sometime, err := time.Date(1, 2, 3, 4, 5, 6, 7, time.UTC).MarshalText()
-	if err != nil {
-		// Should never happen
-		t.Fatal(err)
-	}
-
 	original := VersionedObject{
 		Version:   8,
-		Timestamp: sometime,
+		Timestamp: time.Date(1, 2, 3, 4, 5, 6, 7, time.UTC),
 		Data:      []byte("original text"),
 	}
 
 	marshalled := original.Marshal()
 
 	unmarshalled := VersionedObject{}
-	err = unmarshalled.Unmarshal(marshalled)
+	err := unmarshalled.Unmarshal(marshalled)
 	if err != nil {
 		// Should never happen
 		t.Fatal(err)
@@ -57,21 +57,12 @@ func TestVersionedKV_Get_Upgrade(t *testing.T) {
 	kv := make(ekv.Memstore)
 	vkv := NewVersionedKV(kv)
 	key := MakeKeyPrefix("test", 0) + "12345"
-	now := time.Now()
-	nowText, err := now.MarshalText()
-	if err != nil {
-		//Should never happen
-		t.Fatal(err)
-	}
 	original := VersionedObject{
 		Version:   0,
-		Timestamp: nowText,
+		Timestamp: time.Now(),
 		Data:      []byte("not upgraded"),
 	}
 	originalSerialized := original.Marshal()
-	if err != nil {
-		t.Fatal(err)
-	}
 	kv[key] = originalSerialized
 
 	result, err := vkv.Get(key)
@@ -90,21 +81,12 @@ func TestVersionedKV_Get(t *testing.T) {
 	vkv := NewVersionedKV(kv)
 	originalVersion := uint64(1)
 	key := MakeKeyPrefix("test", originalVersion) + "12345"
-	now := time.Now()
-	nowText, err := now.MarshalText()
-	if err != nil {
-		//Should never happen
-		t.Fatal(err)
-	}
 	original := VersionedObject{
 		Version:   originalVersion,
-		Timestamp: nowText,
+		Timestamp: time.Now(),
 		Data:      []byte("not upgraded"),
 	}
 	originalSerialized := original.Marshal()
-	if err != nil {
-		t.Fatal(err)
-	}
 	kv[key] = originalSerialized
 
 	result, err := vkv.Get(key)
@@ -122,18 +104,12 @@ func TestVersionedKV_Set(t *testing.T) {
 	vkv := NewVersionedKV(kv)
 	originalVersion := uint64(1)
 	key := MakeKeyPrefix("test", originalVersion) + "12345"
-	now := time.Now()
-	nowText, err := now.MarshalText()
-	if err != nil {
-		//Should never happen
-		t.Fatal(err)
-	}
 	original := VersionedObject{
 		Version:   originalVersion,
-		Timestamp: nowText,
+		Timestamp: time.Now(),
 		Data:      []byte("not upgraded"),
 	}
-	err = vkv.Set(key, &original)
+	err := vkv.Set(key, &original)
 	if err != nil {
 		t.Fatal(err)
 	}