Merge remote-tracking branch 'origin/peppa/newClient' into peppa/newClient

context/stoppable/cleanup.go

@@ -7,10 +7,10 @@ import (
 	"time"
 )
 
-// Wraps any stoppable and runs a callback after to stop for cleanup behavior
-// the cleanup is run under the remainder of the timeout but will not be canceled
-// if the timeout runs out
-// the cleanup function does not run if the thread does not stop
+// Cleanup wraps any stoppable and runs a callback after to stop for cleanup
+// behavior. The cleanup is run under the remainder of the timeout but will not
+// be canceled if the timeout runs out. The cleanup function does not run if the
+// thread does not stop.
 type Cleanup struct {
 	stop Stoppable
 	// the clean function receives how long it has to run before the timeout,
@@ -20,7 +20,7 @@ type Cleanup struct {
 	once    sync.Once
 }
 
-// Creates a new cleanup from the passed stoppable and the function
+// NewCleanup creates a new Cleanup from the passed stoppable and function.
 func NewCleanup(stop Stoppable, clean func(duration time.Duration) error) *Cleanup {
 	return &Cleanup{
 		stop:    stop,
@@ -29,18 +29,19 @@ func NewCleanup(stop Stoppable, clean func(duration time.Duration) error) *Clean
 	}
 }
 
-// returns true if the thread is still running and its cleanup has completed
+// IsRunning returns true if the thread is still running and its cleanup has
+// completed.
 func (c *Cleanup) IsRunning() bool {
 	return atomic.LoadUint32(&c.running) == 1
 }
 
-// returns the name of the stoppable denoting it has cleanup
+// Name returns the name of the stoppable denoting it has cleanup.
 func (c *Cleanup) Name() string {
 	return c.stop.Name() + " with cleanup"
 }
 
-// stops the contained stoppable and runs the cleanup function after.
-// the cleanup function does not run if the thread does not stop
+// Close stops the contained stoppable and runs the cleanup function after. The
+// cleanup function does not run if the thread does not stop.
 func (c *Cleanup) Close(timeout time.Duration) error {
 	var err error
 
@@ -49,14 +50,14 @@ func (c *Cleanup) Close(timeout time.Duration) error {
 			defer atomic.StoreUint32(&c.running, 0)
 			start := time.Now()
 
-			//run the stopable
+			// Run the stoppable
 			if err := c.stop.Close(timeout); err != nil {
 				err = errors.WithMessagef(err, "Cleanup for %s not executed",
 					c.stop.Name())
 				return
 			}
 
-			//run the cleanup function with the remaining time as a timeout
+			// Run the cleanup function with the remaining time as a timeout
 			elapsed := time.Since(start)
 
 			complete := make(chan error, 1)
@@ -69,11 +70,11 @@ func (c *Cleanup) Close(timeout time.Duration) error {
 			select {
 			case err := <-complete:
 				if err != nil {
-					err = errors.WithMessagef(err, "Cleanup for %s "+
-						"failed", c.stop.Name())
+					err = errors.WithMessagef(err, "Cleanup for %s failed",
+						c.stop.Name())
 				}
 			case <-timer.C:
-				err = errors.Errorf("Clean up for %s timedout", c.stop.Name())
+				err = errors.Errorf("Clean up for %s timeout", c.stop.Name())
 			}
 		})
 

context/stoppable/cleanup_test.go

+package stoppable
+
+import (
+	"testing"
+)
+
+// Tests happy path of NewCleanup().
+func TestNewCleanup(t *testing.T) {
+	single := NewSingle("test name")
+	cleanup := NewCleanup(single, single.Close)
+
+	if cleanup.stop != single || cleanup.running != 0 {
+		t.Errorf("NewCleanup() returned Single with incorrect values."+
+			"\n\texpected:  stop: %v  running: %d\n\treceived:  stop: %v  running: %d",
+			single, cleanup.stop, 0, cleanup.running)
+	}
+}
+
+// Tests happy path of Cleanup.IsRunning().
+func TestCleanup_IsRunning(t *testing.T) {
+	single := NewSingle("test name")
+	cleanup := NewCleanup(single, single.Close)
+
+	if cleanup.IsRunning() {
+		t.Errorf("IsRunning() returned false when it should be running.")
+	}
+
+	cleanup.running = 1
+	if !cleanup.IsRunning() {
+		t.Errorf("IsRunning() returned true when it should not be running.")
+	}
+}
+
+// Tests happy path of Cleanup.Name().
+func TestCleanup_Name(t *testing.T) {
+	name := "test name"
+	single := NewSingle(name)
+	cleanup := NewCleanup(single, single.Close)
+
+	if name+" with cleanup" != cleanup.Name() {
+		t.Errorf("Name() returned the incorrect string."+
+			"\n\texpected: %s\n\treceived: %s", name+" with cleanup", cleanup.Name())
+	}
+}
+
+// Tests happy path of Cleanup.Close().
+func TestCleanup_Close(t *testing.T) {
+	single := NewSingle("test name")
+	cleanup := NewCleanup(single, single.Close)
+
+	err := cleanup.Close(0)
+	if err != nil {
+		t.Errorf("Close() returned an error: %v", err)
+	}
+}

context/stoppable/multi.go

@@ -17,7 +17,7 @@ type Multi struct {
 	once       sync.Once
 }
 
-//returns a new multi stoppable
+// NewMulti returns a new multi stoppable.
 func NewMulti(name string) *Multi {
 	return &Multi{
 		name:    name,
@@ -25,20 +25,20 @@ func NewMulti(name string) *Multi {
 	}
 }
 
-// returns true if the thread is still running
+// IsRunning returns true if the thread is still running.
 func (m *Multi) IsRunning() bool {
 	return atomic.LoadUint32(&m.running) == 1
 }
 
-// adds the given stoppable to the list of stoppables
+// Add adds the given stoppable to the list of stoppables.
 func (m *Multi) Add(stoppable Stoppable) {
 	m.mux.Lock()
 	m.stoppables = append(m.stoppables, stoppable)
 	m.mux.Unlock()
 }
 
-// returns the name of the multi stoppable and the names of all stoppables it
-// contains
+// Name returns the name of the multi stoppable and the names of all stoppables
+// it contains.
 func (m *Multi) Name() string {
 	m.mux.RLock()
 	names := m.name + ": {"
@@ -54,8 +54,8 @@ func (m *Multi) Name() string {
 	return names
 }
 
-// closes all child stoppers. It does not return their errors and assumes they
-// print them to the log
+// Close closes all child stoppers. It does not return their errors and assumes
+// they print them to the log.
 func (m *Multi) Close(timeout time.Duration) error {
 	var err error
 	m.once.Do(
@@ -63,18 +63,17 @@ func (m *Multi) Close(timeout time.Duration) error {
 			atomic.StoreUint32(&m.running, 0)
 
 			numErrors := uint32(0)
-
 			wg := &sync.WaitGroup{}
 
 			m.mux.Lock()
 			for _, stoppable := range m.stoppables {
 				wg.Add(1)
-				go func() {
+				go func(stoppable Stoppable) {
 					if stoppable.Close(timeout) != nil {
 						atomic.AddUint32(&numErrors, 1)
 					}
 					wg.Done()
-				}()
+				}(stoppable)
 			}
 			m.mux.Unlock()
 
@@ -89,5 +88,4 @@ func (m *Multi) Close(timeout time.Duration) error {
 		})
 
 	return err
-
 }

context/stoppable/multi_test.go

+package stoppable
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+// Tests happy path of NewMulti().
+func TestNewMulti(t *testing.T) {
+	name := "test name"
+	multi := NewMulti(name)
+
+	if multi.name != name || multi.running != 1 {
+		t.Errorf("NewMulti() returned Multi with incorrect values."+
+			"\n\texpected:  name: %s  running: %d\n\treceived:  name: %s  running: %d",
+			name, 1, multi.name, multi.running)
+	}
+}
+
+// Tests happy path of Multi.IsRunning().
+func TestMulti_IsRunning(t *testing.T) {
+	multi := NewMulti("name")
+
+	if !multi.IsRunning() {
+		t.Errorf("IsRunning() returned false when it should be running.")
+	}
+
+	multi.running = 0
+	if multi.IsRunning() {
+		t.Errorf("IsRunning() returned true when it should not be running.")
+	}
+}
+
+// Tests happy path of Multi.Add().
+func TestMulti_Add(t *testing.T) {
+	multi := NewMulti("multi name")
+	singles := []*Single{
+		NewSingle("single name 1"),
+		NewSingle("single name 2"),
+		NewSingle("single name 3"),
+	}
+
+	for _, single := range singles {
+		multi.Add(single)
+	}
+
+	for i, single := range singles {
+		if !reflect.DeepEqual(single, multi.stoppables[i]) {
+			t.Errorf("Add() did not add the correct Stoppables."+
+				"\n\texpected: %#v\n\treceived: %#v", single, multi.stoppables[i])
+		}
+	}
+}
+
+// Tests happy path of Multi.Name().
+func TestMulti_Name(t *testing.T) {
+	name := "test name"
+	multi := NewMulti(name)
+	singles := []*Single{
+		NewSingle("single name 1"),
+		NewSingle("single name 2"),
+		NewSingle("single name 3"),
+	}
+	expectedNames := []string{
+		name + ": {}",
+		name + ": {" + singles[0].name + "}",
+		name + ": {" + singles[0].name + ", " + singles[1].name + "}",
+		name + ": {" + singles[0].name + ", " + singles[1].name + ", " + singles[2].name + "}",
+	}
+
+	for i, single := range singles {
+		if expectedNames[i] != multi.Name() {
+			t.Errorf("Name() returned the incorrect string."+
+				"\n\texpected: %s\n\treceived: %s", expectedNames[0], multi.Name())
+		}
+		multi.Add(single)
+	}
+}
+
+// Tests happy path of Multi.Close().
+func TestMulti_Close(t *testing.T) {
+	// Create new Multi and add Singles to it
+	multi := NewMulti("name")
+	singles := []*Single{
+		NewSingle("single name 1"),
+		NewSingle("single name 2"),
+		NewSingle("single name 3"),
+	}
+	for _, single := range singles {
+		multi.Add(single)
+	}
+
+	go func() {
+		select {
+		case <-singles[0].quit:
+		}
+		select {
+		case <-singles[1].quit:
+		}
+		select {
+		case <-singles[2].quit:
+		}
+	}()
+
+	err := multi.Close(5 * time.Millisecond)
+	if err != nil {
+		t.Errorf("Close() returned an error: %v", err)
+	}
+
+	err = multi.Close(0)
+	if err != nil {
+		t.Errorf("Close() returned an error: %v", err)
+	}
+}

context/stoppable/single.go

@@ -8,8 +8,8 @@ import (
 	"time"
 )
 
-// Single allows stopping a single goroutine using a channel
-// adheres to the stoppable interface
+// Single allows stopping a single goroutine using a channel.
+// It adheres to the stoppable interface.
 type Single struct {
 	name    string
 	quit    chan struct{}
@@ -17,7 +17,7 @@ type Single struct {
 	once    sync.Once
 }
 
-//returns a new single stoppable
+// NewSingle returns a new single stoppable.
 func NewSingle(name string) *Single {
 	return &Single{
 		name:    name,
@@ -26,22 +26,22 @@ func NewSingle(name string) *Single {
 	}
 }
 
-// returns true if the thread is still running
+// IsRunning returns true if the thread is still running.
 func (s *Single) IsRunning() bool {
 	return atomic.LoadUint32(&s.running) == 1
 }
 
-// returns the read only channel it will send the stop signal on
-func (s *Single) Quit() <-chan struct{} {
+// Quit returns the read only channel it will send the stop signal on.
+func (s *Single) Quit() chan<- struct{} {
 	return s.quit
 }
 
-// returns the name of the thread. This is designed to be
+// Name returns the name of the thread. This is designed to be
 func (s *Single) Name() string {
 	return s.name
 }
 
-// Close signals thread to time out and closes if it is still running.
+// Close signals the thread to time out and closes if it is still running.
 func (s *Single) Close(timeout time.Duration) error {
 	var err error
 	s.once.Do(func() {

context/stoppable/single_test.go

+package stoppable
+
+import (
+	"testing"
+	"time"
+)
+
+// Tests happy path of NewSingle().
+func TestNewSingle(t *testing.T) {
+	name := "test name"
+	single := NewSingle(name)
+
+	if single.name != name || single.running != 1 {
+		t.Errorf("NewSingle() returned Single with incorrect values."+
+			"\n\texpected:  name: %s  running: %d\n\treceived:  name: %s  running: %d",
+			name, 1, single.name, single.running)
+	}
+}
+
+// Tests happy path of Single.IsRunning().
+func TestSingle_IsRunning(t *testing.T) {
+	single := NewSingle("name")
+
+	if !single.IsRunning() {
+		t.Errorf("IsRunning() returned false when it should be running.")
+	}
+
+	single.running = 0
+	if single.IsRunning() {
+		t.Errorf("IsRunning() returned true when it should not be running.")
+	}
+}
+
+// Tests happy path of Single.Quit().
+func TestSingle_Quit(t *testing.T) {
+	single := NewSingle("name")
+
+	go func() {
+		time.Sleep(150 * time.Nanosecond)
+		single.Quit() <- struct{}{}
+	}()
+
+	timer := time.NewTimer(2 * time.Millisecond)
+	select {
+	case <-timer.C:
+		t.Errorf("Quit signal not received.")
+	case <-single.quit:
+	}
+}
+
+// Tests happy path of Single.Name().
+func TestSingle_Name(t *testing.T) {
+	name := "test name"
+	single := NewSingle(name)
+
+	if name != single.Name() {
+		t.Errorf("Name() returned the incorrect string."+
+			"\n\texpected: %s\n\treceived: %s", name, single.Name())
+	}
+}
+
+// Test happy path of Single.Close().
+func TestSingle_Close(t *testing.T) {
+	single := NewSingle("name")
+
+	go func() {
+		time.Sleep(150 * time.Nanosecond)
+		select {
+		case <-single.quit:
+		}
+	}()
+
+	err := single.Close(5 * time.Millisecond)
+	if err != nil {
+		t.Errorf("Close() returned an error: %v", err)
+	}
+}
+
+// Tests that Single.Close() returns an error when the timeout is reached.
+func TestSingle_Close_Error(t *testing.T) {
+	single := NewSingle("name")
+	expectedErr := single.name + " failed to close"
+
+	go func() {
+		time.Sleep(3 * time.Millisecond)
+		select {
+		case <-single.quit:
+		}
+	}()
+
+	err := single.Close(2 * time.Millisecond)
+	if err == nil {
+		t.Errorf("Close() did not return the expected error."+
+			"\n\texpected: %v\n\treceived: %v", expectedErr, err)
+	}
+}

context/stoppable/stoppable.go

@@ -2,7 +2,7 @@ package stoppable
 
 import "time"
 
-// Interface for stopping a goroutine
+// Interface for stopping a goroutine.
 type Stoppable interface {
 	Close(timeout time.Duration) error
 	IsRunning() bool

storage/conversation/partner.go

@@ -12,11 +12,13 @@ import (
 	"time"
 )
 
-const conversationKeyPrefix = "conversation"
-const currentConversationVersion = 0
-const maxTruncatedID = math.MaxUint32
-const bottomRegion = maxTruncatedID / 4
-const topRegion = bottomRegion * 3
+const (
+	conversationKeyPrefix      = "conversation"
+	currentConversationVersion = 0
+	maxTruncatedID             = math.MaxUint32
+	bottomRegion               = maxTruncatedID / 4
+	topRegion                  = bottomRegion * 3
+)
 
 type Conversation struct {
 	// Public & stored data
@@ -37,7 +39,8 @@ type conversationDisk struct {
 	NextSendID             uint64
 }
 
-// Returns the Conversation if it can be found, otherwise returns a new partner
+// LoadOrMakeConversation returns the Conversation if it can be found, otherwise
+// returns a new partner.
 func LoadOrMakeConversation(kv *versioned.KV, partner *id.ID) *Conversation {
 
 	c, err := loadConversation(kv, partner)
@@ -61,11 +64,12 @@ func LoadOrMakeConversation(kv *versioned.KV, partner *id.ID) *Conversation {
 	return c
 }
 
-// Finds the full 64 bit message ID and updates the internal last message ID if
-// the new ID is newer
+// ProcessReceivedMessageID finds the full 64-bit message ID and updates the
+// internal last message ID if the new ID is newer.
 func (c *Conversation) ProcessReceivedMessageID(mid uint32) uint64 {
 	c.mux.Lock()
 	defer c.mux.Unlock()
+
 	var high uint32
 	switch cmp(c.lastReceivedID, mid) {
 	case 1:
@@ -101,14 +105,14 @@ func cmp(a, b uint32) int {
 	return 0
 }
 
-//returns the next sendID in both full and truncated formats
+// GetNextSendID returns the next sendID in both full and truncated formats.
 func (c *Conversation) GetNextSendID() (uint64, uint32) {
 	c.mux.Lock()
 	old := c.nextSentID
 	c.nextSentID++
 	if err := c.save(); err != nil {
-		jww.FATAL.Panicf("Failed to save after incrementing the sendID: "+
-			"%s", err)
+		jww.FATAL.Panicf("Failed to save after incrementing the sendID: %s",
+			err)
 	}
 	c.mux.Unlock()
 	return old, uint32(old & 0x00000000FFFFFFFF)

storage/conversation/partner_test.go

+package conversation
+
+import (
+	"gitlab.com/elixxir/client/storage/versioned"
+	"gitlab.com/elixxir/ekv"
+	"gitlab.com/xx_network/primitives/id"
+	"math/rand"
+	"reflect"
+	"testing"
+)
+
+// Tests happy path of LoadOrMakeConversation() when making a new Conversation.
+func TestLoadOrMakeConversation_Make(t *testing.T) {
+	// Set up test values
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	expectedConv := &Conversation{
+		lastReceivedID:         0,
+		numReceivedRevolutions: 0,
+		nextSentID:             0,
+		partner:                partner,
+		kv:                     kv,
+	}
+
+	// Create new Conversation
+	conv := LoadOrMakeConversation(kv, partner)
+
+	// Check that the result matches the expected Conversation
+	if !reflect.DeepEqual(expectedConv, conv) {
+		t.Errorf("LoadOrMakeConversation() made unexpected Conversation."+
+			"\n\texpected: %+v\n\treceived: %+v", expectedConv, conv)
+	}
+}
+
+// Tests happy path of LoadOrMakeConversation() when loading a Conversation.
+func TestLoadOrMakeConversation_Load(t *testing.T) {
+	// Set up test values
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	expectedConv := LoadOrMakeConversation(kv, partner)
+
+	// Load Conversation
+	conv := LoadOrMakeConversation(kv, partner)
+
+	// Check that the result matches the expected Conversation
+	if !reflect.DeepEqual(expectedConv, conv) {
+		t.Errorf("LoadOrMakeConversation() made unexpected Conversation."+
+			"\n\texpected: %+v\n\treceived: %+v", expectedConv, conv)
+	}
+}
+
+// Tests case 1 of Conversation.ProcessReceivedMessageID().
+func TestConversation_ProcessReceivedMessageID_Case_1(t *testing.T) {
+	// Set up test values
+	mid := uint32(5)
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	expectedConv := LoadOrMakeConversation(kv, partner)
+	expectedConv.lastReceivedID = mid
+	expectedConv.numReceivedRevolutions = 1
+	conv := LoadOrMakeConversation(kv, partner)
+	conv.lastReceivedID = topRegion + 5
+	expectedResult := uint64(expectedConv.numReceivedRevolutions)<<32 | uint64(mid)
+
+	result := conv.ProcessReceivedMessageID(mid)
+	if result != expectedResult {
+		t.Errorf("ProcessReceivedMessageID() did not product the expected "+
+			"result.\n\texpected: %+v\n\trecieved: %+v",
+			expectedResult, result)
+	}
+	if !reflect.DeepEqual(expectedConv, conv) {
+		t.Errorf("ProcessReceivedMessageID() did not product the expected "+
+			"Conversation.\n\texpected: %+v\n\trecieved: %+v",
+			expectedConv, conv)
+	}
+}
+
+// Tests case 0 of Conversation.ProcessReceivedMessageID().
+func TestConversation_ProcessReceivedMessageID_Case_0(t *testing.T) {
+	// Set up test values
+	mid := uint32(5)
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	expectedConv := LoadOrMakeConversation(kv, partner)
+	expectedConv.lastReceivedID = mid
+	conv := LoadOrMakeConversation(kv, partner)
+	expectedResult := uint64(expectedConv.numReceivedRevolutions)<<32 | uint64(mid)
+
+	result := conv.ProcessReceivedMessageID(mid)
+	if result != expectedResult {
+		t.Errorf("ProcessReceivedMessageID() did not product the expected "+
+			"result.\n\texpected: %+v\n\trecieved: %+v",
+			expectedResult, result)
+	}
+	if !reflect.DeepEqual(expectedConv, conv) {
+		t.Errorf("ProcessReceivedMessageID() did not product the expected "+
+			"Conversation.\n\texpected: %+v\n\trecieved: %+v",
+			expectedConv, conv)
+	}
+}
+
+// Tests case -1 of Conversation.ProcessReceivedMessageID().
+func TestConversation_ProcessReceivedMessageID_Case_Neg1(t *testing.T) {
+	// Set up test values
+	mid := uint32(topRegion + 5)
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	expectedConv := LoadOrMakeConversation(kv, partner)
+	expectedConv.lastReceivedID = bottomRegion - 5
+	conv := LoadOrMakeConversation(kv, partner)
+	conv.lastReceivedID = bottomRegion - 5
+	expectedResult := uint64(expectedConv.numReceivedRevolutions-1)<<32 | uint64(mid)
+
+	result := conv.ProcessReceivedMessageID(mid)
+	if result != expectedResult {
+		t.Errorf("ProcessReceivedMessageID() did not product the expected "+
+			"result.\n\texpected: %+v\n\trecieved: %+v",
+			expectedResult, result)
+	}
+	if !reflect.DeepEqual(expectedConv, conv) {
+		t.Errorf("ProcessReceivedMessageID() did not product the expected "+
+			"Conversation.\n\texpected: %+v\n\trecieved: %+v",
+			expectedConv, conv)
+	}
+}
+
+// Tests happy path of Conversation.GetNextSendID().
+func TestConversation_GetNextSendID(t *testing.T) {
+	// Set up test values
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	conv := LoadOrMakeConversation(kv, partner)
+	conv.nextSentID = maxTruncatedID - 100
+
+	for i := uint64(maxTruncatedID - 100); i < maxTruncatedID+100; i++ {
+		fullID, truncID := conv.GetNextSendID()
+		if fullID != i {
+			t.Errorf("Returned incorrect full sendID."+
+				"\n\texpected: %d\n\treceived: %d", i, fullID)
+		}
+		if truncID != uint32(i) {
+			t.Errorf("Returned incorrect truncated sendID."+
+				"\n\texpected: %d\n\treceived: %d", uint32(i), truncID)
+		}
+	}
+}
+
+// Tests the happy path of save() and loadConversation().
+func TestConversation_save_load(t *testing.T) {
+	kv := versioned.NewKV(make(ekv.Memstore))
+	partner := id.NewIdFromString("partner ID", id.User, t)
+	expectedConv := makeRandomConv(kv, partner)
+	expectedErr := "loadConversation() produced an error: Failed to Load " +
+		"conversation: object not found"
+
+	err := expectedConv.save()
+	if err != nil {
+		t.Errorf("save() produced an error: %v", err)
+	}
+
+	testConv, err := loadConversation(kv, partner)
+	if err != nil {
+		t.Errorf("loadConversation() produced an error: %v", err)
+	}
+
+	if !reflect.DeepEqual(expectedConv, testConv) {
+		t.Errorf("saving and loading Conversation failed."+
+			"\n\texpected: %+v\n\treceived: %+v", expectedConv, testConv)
+	}
+
+	_, err = loadConversation(versioned.NewKV(make(ekv.Memstore)), partner)
+	if err == nil {
+		t.Errorf("loadConversation() failed to produce an error."+
+			"\n\texpected: %s\n\treceived: %v", expectedErr, nil)
+	}
+}
+
+// Tests the happy path of marshal() and unmarshal().
+func TestConversation_marshal_unmarshal(t *testing.T) {
+	expectedConv := makeRandomConv(versioned.NewKV(make(ekv.Memstore)),
+		id.NewIdFromString("partner ID", id.User, t))
+	testConv := LoadOrMakeConversation(expectedConv.kv, expectedConv.partner)
+
+	data, err := expectedConv.marshal()
+	if err != nil {
+		t.Errorf("marshal() returned an error: %v", err)
+	}
+
+	err = testConv.unmarshal(data)
+	if err != nil {
+		t.Errorf("unmarshal() returned an error: %v", err)
+	}
+
+	if !reflect.DeepEqual(expectedConv, testConv) {
+		t.Errorf("marshaling and unmarshaling Conversation failed."+
+			"\n\texpected: %+v\n\treceived: %+v", expectedConv, testConv)
+	}
+}
+
+func makeRandomConv(kv *versioned.KV, partner *id.ID) *Conversation {
+	c := LoadOrMakeConversation(kv, partner)
+	c.lastReceivedID = rand.Uint32()
+	c.numReceivedRevolutions = rand.Uint32()
+	c.nextSentID = rand.Uint64()
+
+	return c
+}

storage/utility/dh_test.go

+package utility
+
+import (
+	"gitlab.com/elixxir/client/storage/versioned"
+	"gitlab.com/elixxir/ekv"
+	"testing"
+)
+
+// Unit test for StoreCyclicKey
+func TestStoreCyclicKey(t *testing.T) {
+	kv := make(ekv.Memstore)
+	vkv := versioned.NewKV(kv)
+	grp := getTestGroup()
+	x := grp.NewInt(77)
+
+	err := StoreCyclicKey(vkv, x, "testKey")
+	if err != nil {
+		t.Error("Failed to store cyclic key")
+	}
+}
+
+// Unit test for LoadCyclicKey
+func TestLoadCyclicKey(t *testing.T) {
+	kv := make(ekv.Memstore)
+	vkv := versioned.NewKV(kv)
+	grp := getTestGroup()
+	x := grp.NewInt(77)
+
+	intKey := "testKey"
+	err := StoreCyclicKey(vkv, x, intKey)
+	if err != nil {
+		t.Errorf("Failed to store cyclic key: %+v", err)
+	}
+
+	loaded, err := LoadCyclicKey(vkv, intKey)
+	if err != nil {
+		t.Errorf("Failed to load cyclic key: %+v", err)
+	}
+	if loaded.Cmp(x) != 0 {
+		t.Errorf("Stored int did not match received.  Stored: %v, Received: %v", x, loaded)
+	}
+}

storage/utility/group_test.go

+package utility
+
+import (
+	"gitlab.com/elixxir/client/storage/versioned"
+	"gitlab.com/elixxir/crypto/cyclic"
+	"gitlab.com/elixxir/crypto/large"
+	"gitlab.com/elixxir/ekv"
+	"testing"
+)
+
+// Unit test for StoreGroup
+func TestStoreGroup(t *testing.T) {
+	kv := make(ekv.Memstore)
+	vkv := versioned.NewKV(kv)
+	grp := getTestGroup()
+	err := StoreGroup(vkv, grp, "testKey")
+	if err != nil {
+		t.Errorf("Failed to store group in kv: %+v", err)
+	}
+}
+
+// Unit test for LoadGroup
+func TestLoadGroup(t *testing.T) {
+	kv := make(ekv.Memstore)
+	vkv := versioned.NewKV(kv)
+	grp := getTestGroup()
+
+	grpKey := "testKey"
+	err := StoreGroup(vkv, grp, grpKey)
+	if err != nil {
+		t.Errorf("Failed to store group in kv: %+v", err)
+	}
+
+	loaded, err := LoadGroup(vkv, grpKey)
+	if err != nil {
+		t.Errorf("Failed to load stored group: %+v", err)
+	}
+	if grp.GetFingerprint() != loaded.GetFingerprint() {
+		t.Errorf("Stored & received group fingerprints don't match.  Stored: %v, Received: %v",
+			grp.GetFingerprint(), loaded.GetFingerprint())
+	}
+}
+
+func getTestGroup() *cyclic.Group {
+	return cyclic.NewGroup(
+		large.NewIntFromString("9DB6FB5951B66BB6FE1E140F1D2CE5502374161FD6538DF1648218642F0B5C48"+
+			"C8F7A41AADFA187324B87674FA1822B00F1ECF8136943D7C55757264E5A1A44F"+
+			"FE012E9936E00C1D3E9310B01C7D179805D3058B2A9F4BB6F9716BFE6117C6B5"+
+			"B3CC4D9BE341104AD4A80AD6C94E005F4B993E14F091EB51743BF33050C38DE2"+
+			"35567E1B34C3D6A5C0CEAA1A0F368213C3D19843D0B4B09DCB9FC72D39C8DE41"+
+			"F1BF14D4BB4563CA28371621CAD3324B6A2D392145BEBFAC748805236F5CA2FE"+
+			"92B871CD8F9C36D3292B5509CA8CAA77A2ADFC7BFD77DDA6F71125A7456FEA15"+
+			"3E433256A2261C6A06ED3693797E7995FAD5AABBCFBE3EDA2741E375404AE25B", 16),
+		large.NewIntFromString("5C7FF6B06F8F143FE8288433493E4769C4D988ACE5BE25A0E24809670716C613"+
+			"D7B0CEE6932F8FAA7C44D2CB24523DA53FBE4F6EC3595892D1AA58C4328A06C4"+
+			"6A15662E7EAA703A1DECF8BBB2D05DBE2EB956C142A338661D10461C0D135472"+
+			"085057F3494309FFA73C611F78B32ADBB5740C361C9F35BE90997DB2014E2EF5"+
+			"AA61782F52ABEB8BD6432C4DD097BC5423B285DAFB60DC364E8161F4A2A35ACA"+
+			"3A10B1C4D203CC76A470A33AFDCBDD92959859ABD8B56E1725252D78EAC66E71"+
+			"BA9AE3F1DD2487199874393CD4D832186800654760E1E34C09E4D155179F9EC0"+
+			"DC4473F996BDCE6EED1CABED8B6F116F7AD9CF505DF0F998E34AB27514B0FFE7", 16))
+}