diff --git a/channels/adminListener_test.go b/channels/adminListener_test.go
index 7fd37cb727dc5b5ee9fa0dda1a4e527757d31556..669b9561e866b68446774ee3d914a337924c5b3a 100644
--- a/channels/adminListener_test.go
+++ b/channels/adminListener_test.go
@@ -49,7 +49,6 @@ func (taed *triggerAdminEventDummy) triggerAdminEvent(chID *id.ID,
 
 // Tests the happy path.
 func TestAdminListener_Listen(t *testing.T) {
-
 	// Build inputs
 	chID := &id.ID{}
 	chID[0] = 1
@@ -149,10 +148,9 @@ func TestAdminListener_Listen_BadRound(t *testing.T) {
 
 	// Check the results
 	if dummy.gotData {
-		t.Fatalf("payload handled when it should have failed due to " +
-			"a round issue")
+		t.Fatal(
+			"Payload handled when it should have failed due to a round issue.")
 	}
-
 }
 
 // Tests that the message is rejected when the channel message is malformed.
@@ -186,7 +184,6 @@ func TestAdminListener_Listen_BadChannelMessage(t *testing.T) {
 		t.Fatalf("payload handled when it should have failed due to " +
 			"a malformed channel message")
 	}
-
 }
 
 // Tests that the message is rejected when the sized broadcast message is
diff --git a/channels/dummyNameServer_test.go b/channels/dummyNameServer_test.go
index 183da2abaa10cbd811048023c6447f61f3261ae4..444e5bd2188268c2eeb9e9a74b5b4bec60da8616 100644
--- a/channels/dummyNameServer_test.go
+++ b/channels/dummyNameServer_test.go
@@ -24,7 +24,6 @@ func TestNewDummyNameService(t *testing.T) {
 	if err != nil {
 		t.Fatalf("NewDummyNameService error: %+v", err)
 	}
-
 }
 
 // Smoke test.
@@ -38,10 +37,8 @@ func TestDummyNameService_GetUsername(t *testing.T) {
 
 	if username != ns.GetUsername() {
 		t.Fatalf("GetUsername did not return expected value."+
-			"\nExpected: %s"+
-			"\nReceived: %s", username, ns.GetUsername())
+			"\nexpected: %s\nreceived: %s", username, ns.GetUsername())
 	}
-
 }
 
 // Smoke test.
@@ -57,16 +54,15 @@ func TestDummyNameService_SignChannelMessage(t *testing.T) {
 
 	signature, err := ns.SignChannelMessage(message)
 	if err != nil {
-		t.Fatalf("SignChannelMessage error: %v", err)
+		t.Fatalf("SignChannelMessage error: %+v", err)
 	}
 
 	if len(signature) != ed25519.SignatureSize {
 		t.Errorf("DummyNameService's SignChannelMessage did not return a "+
 			"signature of expected size, according to ed25519 specifications."+
-			"\nExpected: %d"+
-			"\nReceived: %d", ed25519.SignatureSize, len(signature))
+			"\nexpected: %d\nreceived: %d",
+			ed25519.SignatureSize, len(signature))
 	}
-
 }
 
 // Smoke test.
@@ -83,11 +79,9 @@ func TestDummyNameService_GetChannelValidationSignature(t *testing.T) {
 	if len(validationSig) != ed25519.SignatureSize {
 		t.Errorf("DummyNameService's GetChannelValidationSignature did not "+
 			"return a validation signature of expected size, according to "+
-			"ed25519 specifications."+
-			"\nExpected: %d"+
-			"\nReceived: %d", ed25519.SignatureSize, len(validationSig))
+			"ed25519 specifications.\nexpected: %d\nreceived: %d",
+			ed25519.SignatureSize, len(validationSig))
 	}
-
 }
 
 // Smoke test.
diff --git a/channels/emoji_test.go b/channels/emoji_test.go
index ea0f2a3bae58903ecd785fd1eb60727dde6032bf..d85602662ddfc982596c8ca91ccc2c4590bcbea5 100644
--- a/channels/emoji_test.go
+++ b/channels/emoji_test.go
@@ -34,19 +34,21 @@ func TestValidateReaction(t *testing.T) {
 }*/
 
 func TestValidateReaction(t *testing.T) {
-
-	testReactions := []string{"🍆", "😂", "❤", "🤣", "👍", "😭", "🙏", "😘", "🥰",
-		"😍", "😊", "☺", "A", "b", "AA", "1", "🍆🍆", "🍆A", "👍👍👍", "👍😘A"}
+	testReactions := []string{
+		"🍆", "😂", "❤", "🤣", "👍", "😭", "🙏", "😘", "🥰", "😍", "😊",
+		"☺", "A", "b", "AA", "1", "🍆🍆", "🍆A", "👍👍👍", "👍😘A",
+	}
 
 	expected := []error{
-		nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-		nil, nil, InvalidReaction, nil,
-		InvalidReaction, InvalidReaction, InvalidReaction, InvalidReaction}
+		nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+		InvalidReaction, nil, InvalidReaction, InvalidReaction, InvalidReaction,
+		InvalidReaction,
+	}
 
 	for i, r := range testReactions {
 		err := ValidateReaction(r)
 		if err != expected[i] {
-			t.Errorf("Got incorrect response for `%s` (%d): "+
+			t.Errorf("Got incorrect response for %q (%d): "+
 				"`%s` vs `%s`", r, i, err, expected[i])
 		}
 	}
diff --git a/channels/eventModel_test.go b/channels/eventModel_test.go
index e1f566c74bc152e3665d483132a11953d3bf2ca8..6f0081be53b0f2ca392ec09c6950df11e9d97bcc 100644
--- a/channels/eventModel_test.go
+++ b/channels/eventModel_test.go
@@ -10,7 +10,6 @@ package channels
 import (
 	"bytes"
 	"crypto/ed25519"
-	"fmt"
 	"github.com/golang/protobuf/proto"
 	"gitlab.com/elixxir/client/cmix/identity/receptionID"
 	"gitlab.com/elixxir/client/cmix/rounds"
@@ -70,7 +69,6 @@ func (m *MockEvent) ReceiveReply(channelID *id.ID,
 	messageID cryptoChannel.MessageID, reactionTo cryptoChannel.MessageID,
 	nickname, text string, _ ed25519.PublicKey, _ uint8, timestamp time.Time,
 	lease time.Duration, round rounds.Round, _ MessageType, _ SentStatus) uint64 {
-	fmt.Println(reactionTo)
 	m.eventReceive = eventReceive{
 		channelID:  channelID,
 		messageID:  messageID,
@@ -462,7 +460,7 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
 
 	textMarshaled, err := proto.Marshal(textPayload)
 	if err != nil {
-		t.Fatalf("failed to marshael the message proto: %+v", err)
+		t.Fatalf("Failed to marshael the message proto: %+v", err)
 	}
 
 	msgID := cryptoChannel.MakeMessageID(textMarshaled, chID)
@@ -471,7 +469,7 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	senderNickname := "Alice"
@@ -498,8 +496,7 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
 	}
 
 	if !me.eventReceive.reactionTo.Equals(cryptoChannel.MessageID{}) {
-		t.Errorf("Reaction ID is not blank, %s",
-			me.eventReceive.reactionTo)
+		t.Errorf("Reaction ID is not blank, %s", me.eventReceive.reactionTo)
 	}
 
 	if me.eventReceive.nickname != senderNickname {
@@ -525,7 +522,6 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
 
 func TestEvents_receiveTextMessage_Reply(t *testing.T) {
 	me := &MockEvent{}
-
 	e := initEvents(me)
 
 	// craft the input for the event
@@ -542,7 +538,7 @@ func TestEvents_receiveTextMessage_Reply(t *testing.T) {
 
 	textMarshaled, err := proto.Marshal(textPayload)
 	if err != nil {
-		t.Fatalf("failed to marshael the message proto: %+v", err)
+		t.Fatalf("Failed to marshael the message proto: %+v", err)
 	}
 
 	msgID := cryptoChannel.MakeMessageID(textMarshaled, chID)
@@ -605,7 +601,6 @@ func TestEvents_receiveTextMessage_Reply(t *testing.T) {
 
 func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
 	me := &MockEvent{}
-
 	e := initEvents(me)
 
 	// craft the input for the event
@@ -622,7 +617,7 @@ func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
 
 	textMarshaled, err := proto.Marshal(textPayload)
 	if err != nil {
-		t.Fatalf("failed to marshael the message proto: %+v", err)
+		t.Fatalf("Failed to marshael the message proto: %+v", err)
 	}
 
 	msgID := cryptoChannel.MakeMessageID(textMarshaled, chID)
@@ -658,8 +653,7 @@ func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
 	}
 
 	if !me.eventReceive.reactionTo.Equals(cryptoChannel.MessageID{}) {
-		t.Errorf("Reaction ID is not blank, %s",
-			me.eventReceive.reactionTo)
+		t.Errorf("Reaction ID is not blank, %s", me.eventReceive.reactionTo)
 	}
 
 	if me.eventReceive.nickname != senderUsername {
@@ -668,8 +662,8 @@ func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
 	}
 
 	if me.eventReceive.timestamp != ts {
-		t.Errorf("Message timestamp did not propogate correctly, "+
-			"%s vs %s", me.eventReceive.timestamp, ts)
+		t.Errorf("Message timestamp did not propogate correctly, %s vs %s",
+			me.eventReceive.timestamp, ts)
 	}
 
 	if me.eventReceive.lease != lease {
@@ -685,7 +679,6 @@ func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
 
 func TestEvents_receiveReaction(t *testing.T) {
 	me := &MockEvent{}
-
 	e := initEvents(me)
 
 	// craft the input for the event
@@ -702,7 +695,7 @@ func TestEvents_receiveReaction(t *testing.T) {
 
 	textMarshaled, err := proto.Marshal(textPayload)
 	if err != nil {
-		t.Fatalf("failed to marshael the message proto: %+v", err)
+		t.Fatalf("Failed to marshael the message proto: %+v", err)
 	}
 
 	msgID := cryptoChannel.MakeMessageID(textMarshaled, chID)
@@ -738,8 +731,8 @@ func TestEvents_receiveReaction(t *testing.T) {
 	}
 
 	if !me.eventReceive.reactionTo.Equals(replyMsgId) {
-		t.Errorf("Reaction ID is not equal to what was passed in, "+
-			"%s vs %s", me.eventReceive.reactionTo, replyMsgId)
+		t.Errorf("Reaction ID is not equal to what was passed in, %s vs %s",
+			me.eventReceive.reactionTo, replyMsgId)
 	}
 
 	if me.eventReceive.nickname != senderUsername {
@@ -765,7 +758,6 @@ func TestEvents_receiveReaction(t *testing.T) {
 
 func TestEvents_receiveReaction_InvalidReactionMessageID(t *testing.T) {
 	me := &MockEvent{}
-
 	e := initEvents(me)
 
 	// craft the input for the event
@@ -782,7 +774,7 @@ func TestEvents_receiveReaction_InvalidReactionMessageID(t *testing.T) {
 
 	textMarshaled, err := proto.Marshal(textPayload)
 	if err != nil {
-		t.Fatalf("failed to marshael the message proto: %+v", err)
+		t.Fatalf("Failed to marshael the message proto: %+v", err)
 	}
 
 	msgID := cryptoChannel.MakeMessageID(textMarshaled, chID)
@@ -808,34 +800,28 @@ func TestEvents_receiveReaction_InvalidReactionMessageID(t *testing.T) {
 
 	// check the results on the model
 	if me.eventReceive.channelID != nil {
-		t.Errorf("Channel ID did propogated correctly when the reaction " +
-			"is bad")
+		t.Error("Channel ID did propagate correctly when the reaction is bad.")
 	}
 
 	if me.eventReceive.messageID.Equals(msgID) {
-		t.Errorf("Message ID propogated correctly when the reaction is " +
-			"bad")
+		t.Errorf("Message ID propagate correctly when the reaction is bad.")
 	}
 
 	if !me.eventReceive.reactionTo.Equals(cryptoChannel.MessageID{}) {
-		t.Errorf("Reaction ID propogated correctly when the reaction " +
-			"is bad")
+		t.Errorf("Reaction ID propagate correctly when the reaction is bad.")
 	}
 
 	if me.eventReceive.nickname != "" {
-		t.Errorf("SenderID propogated correctly when the reaction " +
-			"is bad")
+		t.Errorf("SenderID propagate correctly when the reaction is bad.")
 	}
 
 	if me.eventReceive.lease != 0 {
-		t.Errorf("Message lease propogated correctly when the " +
-			"reaction is bad")
+		t.Errorf("Message lease propagate correctly when the reaction is bad.")
 	}
 }
 
 func TestEvents_receiveReaction_InvalidReactionContent(t *testing.T) {
 	me := &MockEvent{}
-
 	e := initEvents(me)
 
 	// craft the input for the event
@@ -852,7 +838,7 @@ func TestEvents_receiveReaction_InvalidReactionContent(t *testing.T) {
 
 	textMarshaled, err := proto.Marshal(textPayload)
 	if err != nil {
-		t.Fatalf("failed to marshael the message proto: %+v", err)
+		t.Fatalf("Failed to marshael the message proto: %+v", err)
 	}
 
 	msgID := cryptoChannel.MakeMessageID(textMarshaled, chID)
@@ -871,34 +857,30 @@ func TestEvents_receiveReaction_InvalidReactionContent(t *testing.T) {
 	if err != nil {
 		t.Fatalf(err.Error())
 	}
-	// call the handler
+
+	// Call the handler
 	e.receiveReaction(chID, msgID, 0, senderUsername,
 		textMarshaled, pi.PubKey, pi.CodesetVersion, ts, lease, r, Delivered)
 
-	// check the results on the model
+	// Check the results on the model
 	if me.eventReceive.channelID != nil {
-		t.Errorf("Channel ID did propogated correctly when the reaction " +
-			"is bad")
+		t.Error("Channel ID did propagate correctly when the reaction is bad.")
 	}
 
 	if me.eventReceive.messageID.Equals(msgID) {
-		t.Errorf("Message ID propogated correctly when the reaction is " +
-			"bad")
+		t.Error("Message ID propagate correctly when the reaction is bad.")
 	}
 
 	if !me.eventReceive.reactionTo.Equals(cryptoChannel.MessageID{}) {
-		t.Errorf("Reaction ID propogated correctly when the reaction " +
-			"is bad")
+		t.Error("Reaction ID propagate correctly when the reaction is bad.")
 	}
 
 	if me.eventReceive.nickname != "" {
-		t.Errorf("SenderID propogated correctly when the reaction " +
-			"is bad")
+		t.Error("SenderID propagate correctly when the reaction is bad.")
 	}
 
 	if me.eventReceive.lease != 0 {
-		t.Errorf("Message lease propogated correctly when the " +
-			"reaction is bad")
+		t.Error("Message lease propagate correctly when the reaction is bad.")
 	}
 }
 
diff --git a/channels/identityStore_test.go b/channels/identityStore_test.go
index 3c3d74d57c1348cf0811b733c9334eecb37469f9..a972a0b8dd00923897caf43c8957c7989e650dac 100644
--- a/channels/identityStore_test.go
+++ b/channels/identityStore_test.go
@@ -36,11 +36,8 @@ func TestStoreLoadIdentity(t *testing.T) {
 	}
 
 	if !bytes.Equal(loadedIdentity.Marshal(), privIdentity.Marshal()) {
-		t.Fatalf("Failed to load private identity."+
-			"\nExpected: %s"+
-			"\nReceived: %s",
+		t.Fatalf("Failed to load private identity.\nexpected: %s\nreceived: %s",
 			base64.StdEncoding.EncodeToString(privIdentity.Marshal()),
 			base64.StdEncoding.EncodeToString(loadedIdentity.Marshal()))
 	}
-
 }
diff --git a/channels/joinedChannel_test.go b/channels/joinedChannel_test.go
index 4d73a365a8f7b43a52215464df9943ef069d15c5..dcb2c32e322e0defd7a64d4ddf33eacac6b4d6ab 100644
--- a/channels/joinedChannel_test.go
+++ b/channels/joinedChannel_test.go
@@ -15,6 +15,7 @@ import (
 	"reflect"
 	"sort"
 	"strconv"
+	"sync"
 	"testing"
 	"time"
 
@@ -39,7 +40,7 @@ func Test_manager_store(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -47,7 +48,7 @@ func Test_manager_store(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -86,7 +87,7 @@ func Test_manager_loadChannels(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -94,7 +95,7 @@ func Test_manager_loadChannels(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -169,7 +170,7 @@ func Test_manager_addChannel(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -177,7 +178,7 @@ func Test_manager_addChannel(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -215,7 +216,7 @@ func Test_manager_addChannel_ChannelAlreadyExistsErr(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -223,7 +224,7 @@ func Test_manager_addChannel_ChannelAlreadyExistsErr(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -252,7 +253,7 @@ func Test_manager_removeChannel(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -260,7 +261,7 @@ func Test_manager_removeChannel(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -298,7 +299,7 @@ func Test_manager_removeChannel_ChannelDoesNotExistsErr(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -306,7 +307,7 @@ func Test_manager_removeChannel_ChannelDoesNotExistsErr(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -331,7 +332,7 @@ func Test_manager_getChannel(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -339,7 +340,7 @@ func Test_manager_getChannel(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -373,7 +374,7 @@ func Test_manager_getChannel_ChannelDoesNotExistsErr(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -381,7 +382,7 @@ func Test_manager_getChannel_ChannelDoesNotExistsErr(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -407,7 +408,7 @@ func Test_manager_getChannels(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -415,7 +416,7 @@ func Test_manager_getChannels(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -488,7 +489,7 @@ func Test_loadJoinedChannel(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
@@ -496,7 +497,7 @@ func Test_loadJoinedChannel(t *testing.T) {
 		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
 		mockEventModelBuilder)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Errorf("NewManager error: %+v", err)
 	}
 
 	m := mFace.(*manager)
@@ -590,7 +591,6 @@ func Test_makeJoinedChannelKey_Consistency(t *testing.T) {
 				binary.BigEndian.Uint64(chID[:8]), expected, key)
 		}
 	}
-
 }
 
 // newTestChannel creates a new cryptoBroadcast.Channel in the same way that
@@ -642,10 +642,34 @@ func mockEventModelBuilder(string) (EventModel, error) {
 type mockEventModel struct {
 	joinedCh *cryptoBroadcast.Channel
 	leftCh   *id.ID
+
+	// Used to prevent fix race condition
+	sync.Mutex
 }
 
-func (m *mockEventModel) JoinChannel(c *cryptoBroadcast.Channel) { m.joinedCh = c }
-func (m *mockEventModel) LeaveChannel(c *id.ID)                  { m.leftCh = c }
+func (m *mockEventModel) getJoinedCh() *cryptoBroadcast.Channel {
+	m.Lock()
+	defer m.Unlock()
+	return m.joinedCh
+}
+
+func (m *mockEventModel) getLeftCh() *id.ID {
+	m.Lock()
+	defer m.Unlock()
+	return m.leftCh
+}
+
+func (m *mockEventModel) JoinChannel(c *cryptoBroadcast.Channel) {
+	m.Lock()
+	defer m.Unlock()
+	m.joinedCh = c
+}
+
+func (m *mockEventModel) LeaveChannel(c *id.ID) {
+	m.Lock()
+	defer m.Unlock()
+	m.leftCh = c
+}
 
 func (m *mockEventModel) ReceiveMessage(*id.ID, cryptoChannel.MessageID, string,
 	string, ed25519.PublicKey, uint8, time.Time, time.Duration, rounds.Round,
diff --git a/channels/manager_test.go b/channels/manager_test.go
index 0242ea41a2281dc971cb6102958a3be74d7573b5..1fc7d9e9f9bb297cac9cad69d2af410dbd6d6aee 100644
--- a/channels/manager_test.go
+++ b/channels/manager_test.go
@@ -27,9 +27,10 @@ import (
 )
 
 func TestMain(m *testing.M) {
-	// Many tests trigger WARN prints;, set the out threshold so the WARN prints
+	// Many tests trigger WARN prints; set the out threshold so the WARN prints
 	// can be seen in the logs
 	jww.SetStdoutThreshold(jww.LevelWarn)
+
 	os.Exit(m.Run())
 }
 
@@ -60,7 +61,7 @@ func TestManager_JoinChannel(t *testing.T) {
 
 	err = m.JoinChannel(ch)
 	if err != nil {
-		t.Fatalf("Join Channel Errored: %s", err)
+		t.Fatalf("Join Channel Errored: %+v", err)
 	}
 
 	if _, exists := m.channels[*ch.ReceptionID]; !exists {
@@ -70,8 +71,8 @@ func TestManager_JoinChannel(t *testing.T) {
 	// Wait because the event model is called in another thread
 	time.Sleep(1 * time.Second)
 
-	if mem.joinedCh == nil {
-		t.Errorf("the channel join call was not propogated to the event model")
+	if mem.getJoinedCh() == nil {
+		t.Error("The channel join call was not propagated to the event model.")
 	}
 }
 
@@ -103,12 +104,12 @@ func TestManager_LeaveChannel(t *testing.T) {
 
 	err = m.JoinChannel(ch)
 	if err != nil {
-		t.Fatalf("Join Channel Errored: %s", err)
+		t.Fatalf("Join Channel Errored: %+v", err)
 	}
 
 	err = m.LeaveChannel(ch.ReceptionID)
 	if err != nil {
-		t.Fatalf("Leave Channel Errored: %s", err)
+		t.Fatalf("Leave Channel Errored: %+v", err)
 	}
 
 	if _, exists := m.channels[*ch.ReceptionID]; exists {
@@ -118,9 +119,8 @@ func TestManager_LeaveChannel(t *testing.T) {
 	// Wait because the event model is called in another thread
 	time.Sleep(1 * time.Second)
 
-	if mem.leftCh == nil {
-		t.Errorf("the channel join call was not propogated to the event " +
-			"model")
+	if mem.getLeftCh() == nil {
+		t.Error("The channel join call was not propagated to the event model.")
 	}
 }
 
diff --git a/channels/mutateTimestamp_test.go b/channels/mutateTimestamp_test.go
index e328e6a4d6946df309b3989f3df8d588328227e1..5e8ff98422a2030aea954c1dfa10ee6e96e4d1b6 100644
--- a/channels/mutateTimestamp_test.go
+++ b/channels/mutateTimestamp_test.go
@@ -48,9 +48,9 @@ func TestMutateTimestampDeltaAverage(t *testing.T) {
 	}
 
 	avg := sum / int64(samples)
-	diff := abs(avg - 2502865)
-	if diff > 30000 {
-		t.Fatal()
+	diff := abs(avg - 2_502_865)
+	if diff > 30_000 {
+		t.Fatalf("Difference %d is greater than %d", diff, 30_000)
 	}
 }
 
diff --git a/channels/nickname_test.go b/channels/nickname_test.go
index c49149636f330d22c605f439f3a9ce1a27bc20b4..b851864c91cda77b5d310ca4784d57a3c86638f1 100644
--- a/channels/nickname_test.go
+++ b/channels/nickname_test.go
@@ -105,5 +105,4 @@ func TestNicknameManager_DeleteNickname(t *testing.T) {
 				"that are not set.")
 		}
 	}
-
 }
diff --git a/channels/sendTracker.go b/channels/sendTracker.go
index b439291f0e8361b90b910788e0d74f25590fd6ba..c6c09c6abc57054735423ab1ca0aa6b749d7bbca 100644
--- a/channels/sendTracker.go
+++ b/channels/sendTracker.go
@@ -98,10 +98,9 @@ func loadSendTracker(net Client, kv *versioned.KV, trigger triggerEventFunc,
 		rngSrc:       rngSource,
 	}
 
-	/*if err := st.load(); !kv.Exists(err){
-		jww.FATAL.Panicf("failed to load sent tracker: %+v", err)
-	}*/
-	st.load()
+	if err := st.load(); err != nil && kv.Exists(err) {
+		jww.FATAL.Panicf("Failed to load channels sent tracker: %+v", err)
+	}
 
 	// Denote all unsent messages as failed and clear
 	for uuid, t := range st.unsent {
diff --git a/channels/sendTracker_test.go b/channels/sendTracker_test.go
index e730146bbb8d45dec2456d9f72277ac406daea47..88c154dee4876868ea724420f6d9ffaa9d568462 100644
--- a/channels/sendTracker_test.go
+++ b/channels/sendTracker_test.go
@@ -167,7 +167,6 @@ func TestSendTracker_failedSend(t *testing.T) {
 		if s != Failed {
 			t.Fatalf("Did not receive failed from failed message")
 		}
-		t.Log("Received over trigger chan")
 	case <-timeout.C:
 		t.Fatal("Timed out waiting for trigger chan")
 	}
@@ -240,7 +239,6 @@ func TestSendTracker_send(t *testing.T) {
 	timeout := time.NewTicker(time.Second * 5)
 	select {
 	case <-triggerCh:
-		t.Log("Received over trigger chan")
 	case <-timeout.C:
 		t.Fatal("Timed out waiting for trigger chan")
 	}
@@ -341,7 +339,6 @@ func TestRoundResult_callback(t *testing.T) {
 	timeout := time.NewTicker(time.Second * 5)
 	select {
 	case <-triggerCh:
-		t.Log("Received trigger")
 	case <-timeout.C:
 		t.Fatal("Did not receive update")
 	}
diff --git a/channels/send_test.go b/channels/send_test.go
index fc95c85f51a365524f78716bf991fd3c69419af9..588d357f2e35f0a9aa6f31ee79360e3609201064 100644
--- a/channels/send_test.go
+++ b/channels/send_test.go
@@ -144,7 +144,6 @@ func (m *mockNameService) ValidateChannelMessage(
 }
 
 func TestSendGeneric(t *testing.T) {
-
 	nameService := new(mockNameService)
 	nameService.validChMsg = true
 
@@ -152,7 +151,7 @@ func TestSendGeneric(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(rng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	crng := fastRNG.NewStreamGenerator(100, 5, csprng.NewSystemRNG)
@@ -194,35 +193,28 @@ func TestSendGeneric(t *testing.T) {
 		broadcast: mbc,
 	}
 
-	messageId, roundId, ephemeralId, err := m.SendGeneric(
-		channelID,
-		messageType,
-		msg,
-		validUntil,
-		*params)
+	messageId, _, _, err :=
+		m.SendGeneric(channelID, messageType, msg, validUntil, *params)
 	if err != nil {
-		t.Logf("ERROR %v", err)
-		t.Fail()
+		t.Fatalf("SendGeneric error: %+v", err)
 	}
-	t.Logf("messageId %v, roundId %v, ephemeralId %v",
-		messageId, roundId, ephemeralId)
 
 	// Verify the message was handled correctly
 
 	// Decode the user message
 	umi, err := unmarshalUserMessageInternal(mbc.payload, channelID)
 	if err != nil {
-		t.Fatalf("Failed to decode the user message: %s", err)
+		t.Fatalf("Failed to decode the user message: %+v", err)
 	}
 
 	// Do checks of the data
 	if !umi.GetMessageID().Equals(messageId) {
-		t.Errorf("The message IDs do not match. %s vs %s ",
+		t.Errorf("The message IDs do not match. %s vs %s",
 			umi.messageID, messageId)
 	}
 
 	if !bytes.Equal(umi.GetChannelMessage().Payload, msg) {
-		t.Errorf("The payload does not match. %s vs %s ",
+		t.Errorf("The payload does not match. %s vs %s",
 			umi.GetChannelMessage().Payload, msg)
 	}
 
@@ -235,16 +227,14 @@ func TestSendGeneric(t *testing.T) {
 		t.Errorf("The returned round is incorrect, %d vs %d",
 			umi.GetChannelMessage().RoundID, returnedRound)
 	}
-
 }
 
 func TestAdminGeneric(t *testing.T) {
-
 	prng := rand.New(rand.NewSource(64))
 
 	pi, err := cryptoChannel.GenerateIdentity(prng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	crng := fastRNG.NewStreamGenerator(100, 5, csprng.NewSystemRNG)
@@ -290,29 +280,25 @@ func TestAdminGeneric(t *testing.T) {
 		broadcast: mbc,
 	}
 
-	messageId, roundId, ephemeralId, err := m.SendAdminGeneric(priv,
-		ch.ReceptionID, messageType, msg, validUntil,
-		cmix.GetDefaultCMIXParams())
+	messageId, _, _, err :=
+		m.SendAdminGeneric(priv, ch.ReceptionID, messageType, msg, validUntil,
+			cmix.GetDefaultCMIXParams())
 	if err != nil {
 		t.Fatalf("Failed to SendAdminGeneric: %v", err)
 	}
-	t.Logf("messageId %v, roundId %v, ephemeralId %v",
-		messageId, roundId, ephemeralId)
 
 	// Verify the message was handled correctly
 
 	msgID := cryptoChannel.MakeMessageID(mbc.payload, ch.ReceptionID)
 
 	if !msgID.Equals(messageId) {
-		t.Errorf("The message IDs do not match. %s vs %s ",
-			msgID, messageId)
+		t.Errorf("The message IDs do not match. %s vs %s", msgID, messageId)
 	}
 
 	// Decode the channel message
 	chMgs := &ChannelMessage{}
-	err = proto.Unmarshal(mbc.payload, chMgs)
-	if err != nil {
-		t.Fatalf("Failed to decode the channel message: %s", err)
+	if err = proto.Unmarshal(mbc.payload, chMgs); err != nil {
+		t.Fatalf("Failed to decode the channel message: %+v", err)
 	}
 
 	if !bytes.Equal(chMgs.Payload, msg) {
@@ -331,7 +317,6 @@ func TestAdminGeneric(t *testing.T) {
 }
 
 func TestSendMessage(t *testing.T) {
-
 	nameService := new(mockNameService)
 	nameService.validChMsg = true
 
@@ -339,7 +324,7 @@ func TestSendMessage(t *testing.T) {
 
 	pi, err := cryptoChannel.GenerateIdentity(prng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	crng := fastRNG.NewStreamGenerator(100, 5, csprng.NewSystemRNG)
@@ -380,29 +365,22 @@ func TestSendMessage(t *testing.T) {
 		broadcast: mbc,
 	}
 
-	messageId, roundId, ephemeralId, err := m.SendMessage(
-		channelID,
-		msg,
-		validUntil,
-		*params)
+	messageId, _, _, err := m.SendMessage(channelID, msg, validUntil, *params)
 	if err != nil {
-		t.Logf("ERROR %v", err)
-		t.Fail()
+		t.Fatalf("SendMessage error: %+v", err)
 	}
-	t.Logf("messageId %v, roundId %v, ephemeralId %v",
-		messageId, roundId, ephemeralId)
 
 	// Verify the message was handled correctly
 
 	// Decode the user message
 	umi, err := unmarshalUserMessageInternal(mbc.payload, channelID)
 	if err != nil {
-		t.Fatalf("Failed to decode the user message: %s", err)
+		t.Fatalf("Failed to decode the user message: %+v", err)
 	}
 
 	// Do checks of the data
 	if !umi.GetMessageID().Equals(messageId) {
-		t.Errorf("The message IDs do not match. %s vs %s ",
+		t.Errorf("The message IDs do not match. %s vs %s",
 			umi.messageID, messageId)
 	}
 
@@ -420,7 +398,7 @@ func TestSendMessage(t *testing.T) {
 	txt := &CMIXChannelText{}
 	err = proto.Unmarshal(umi.GetChannelMessage().Payload, txt)
 	if err != nil {
-		t.Fatalf("Could not decode cmix channel text: %s", err)
+		t.Fatalf("Could not decode cmix channel text: %+v", err)
 	}
 
 	if txt.Text != msg {
@@ -433,12 +411,11 @@ func TestSendMessage(t *testing.T) {
 }
 
 func TestSendReply(t *testing.T) {
-
 	prng := rand.New(rand.NewSource(64))
 
 	pi, err := cryptoChannel.GenerateIdentity(prng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	crng := fastRNG.NewStreamGenerator(100, 5, csprng.NewSystemRNG)
@@ -482,26 +459,22 @@ func TestSendReply(t *testing.T) {
 		broadcast: mbc,
 	}
 
-	messageId, roundId, ephemeralId, err := m.SendReply(
-		channelID, msg, replyMsgID, validUntil, *params)
+	messageId, _, _, err :=
+		m.SendReply(channelID, msg, replyMsgID, validUntil, *params)
 	if err != nil {
-		t.Logf("ERROR %v", err)
-		t.Fail()
+		t.Fatalf("SendReply error: %+v", err)
 	}
-	t.Logf("messageId %v, roundId %v, ephemeralId %v",
-		messageId, roundId, ephemeralId)
-
 	// Verify the message was handled correctly
 
 	// Decode the user message
 	umi, err := unmarshalUserMessageInternal(mbc.payload, channelID)
 	if err != nil {
-		t.Fatalf("Failed to decode the user message: %s", err)
+		t.Fatalf("Failed to decode the user message: %+v", err)
 	}
 
 	// Do checks of the data
 	if !umi.GetMessageID().Equals(messageId) {
-		t.Errorf("The message IDs do not match. %s vs %s ",
+		t.Errorf("The message IDs do not match. %s vs %s",
 			umi.messageID, messageId)
 	}
 
@@ -519,7 +492,7 @@ func TestSendReply(t *testing.T) {
 	txt := &CMIXChannelText{}
 	err = proto.Unmarshal(umi.GetChannelMessage().Payload, txt)
 	if err != nil {
-		t.Fatalf("Could not decode cmix channel text: %s", err)
+		t.Fatalf("Could not decode cmix channel text: %+v", err)
 	}
 
 	if txt.Text != msg {
@@ -532,12 +505,11 @@ func TestSendReply(t *testing.T) {
 }
 
 func TestSendReaction(t *testing.T) {
-
 	prng := rand.New(rand.NewSource(64))
 
 	pi, err := cryptoChannel.GenerateIdentity(prng)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatalf("GenerateIdentity error: %+v", err)
 	}
 
 	crng := fastRNG.NewStreamGenerator(100, 5, csprng.NewSystemRNG)
@@ -580,26 +552,22 @@ func TestSendReaction(t *testing.T) {
 		broadcast: mbc,
 	}
 
-	messageId, roundId, ephemeralId, err := m.SendReaction(
-		channelID, msg, replyMsgID, *params)
+	messageId, _, _, err := m.SendReaction(channelID, msg, replyMsgID, *params)
 	if err != nil {
-		t.Logf("ERROR %v", err)
-		t.Fail()
+		t.Fatalf("SendReaction error: %+v", err)
 	}
-	t.Logf("messageId %v, roundId %v, ephemeralId %v",
-		messageId, roundId, ephemeralId)
 
 	// Verify the message was handled correctly
 
 	// Decode the user message
 	umi, err := unmarshalUserMessageInternal(mbc.payload, channelID)
 	if err != nil {
-		t.Fatalf("Failed to decode the user message: %s", err)
+		t.Fatalf("Failed to decode the user message: %+v", err)
 	}
 
 	// Do checks of the data
 	if !umi.GetMessageID().Equals(messageId) {
-		t.Errorf("The message IDs do not match. %s vs %s ",
+		t.Errorf("The message IDs do not match. %s vs %s",
 			umi.messageID, messageId)
 	}
 
@@ -617,7 +585,7 @@ func TestSendReaction(t *testing.T) {
 	txt := &CMIXChannelReaction{}
 	err = proto.Unmarshal(umi.GetChannelMessage().Payload, txt)
 	if err != nil {
-		t.Fatalf("Could not decode cmix channel text: %s", err)
+		t.Fatalf("Could not decode cmix channel text: %+v", err)
 	}
 
 	if txt.Reaction != msg {