From 6020be630f0cbbb137033953c74e7d081a257775 Mon Sep 17 00:00:00 2001
From: Benjamin Wenger <ben@elixxir.ioo>
Date: Sat, 24 Sep 2022 10:14:09 -0700
Subject: [PATCH] all tests pass in channels
---
channels/adminListener_test.go | 6 +-
channels/eventModel_test.go | 245 +++++++++++++++++++++------------
channels/joinedChannel_test.go | 194 +++++++++++++++++++++-----
channels/manager_test.go | 34 ++++-
channels/messages_test.go | 15 +-
channels/sendTracker_test.go | 105 ++++++++++----
channels/send_test.go | 139 ++++++++++++++-----
channels/userListener_test.go | 172 +++--------------------
8 files changed, 553 insertions(+), 357 deletions(-)
diff --git a/channels/adminListener_test.go b/channels/adminListener_test.go
index e32f7b0eb..f52e8fbec 100644
--- a/channels/adminListener_test.go
+++ b/channels/adminListener_test.go
@@ -32,9 +32,9 @@ type triggerAdminEventDummy struct {
}
func (taed *triggerAdminEventDummy) triggerAdminEvent(chID *id.ID,
- cm *ChannelMessage, messageID cryptoChannel.MessageID,
+ cm *ChannelMessage, ts time.Time, messageID cryptoChannel.MessageID,
receptionID receptionID.EphemeralIdentity, round rounds.Round,
- status SentStatus) {
+ status SentStatus) (uint64, error) {
taed.gotData = true
taed.chID = chID
@@ -42,6 +42,8 @@ func (taed *triggerAdminEventDummy) triggerAdminEvent(chID *id.ID,
taed.msgID = messageID
taed.receptionID = receptionID
taed.round = round
+
+ return 0, nil
}
// Tests the happy path.
diff --git a/channels/eventModel_test.go b/channels/eventModel_test.go
index ef1b635a9..5739d93db 100644
--- a/channels/eventModel_test.go
+++ b/channels/eventModel_test.go
@@ -17,6 +17,7 @@ import (
cryptoChannel "gitlab.com/elixxir/crypto/channel"
"gitlab.com/elixxir/primitives/states"
"gitlab.com/xx_network/primitives/id"
+ "math/rand"
"reflect"
"runtime"
"testing"
@@ -24,22 +25,29 @@ import (
)
type eventReceive struct {
- channelID *id.ID
- messageID cryptoChannel.MessageID
- reactionTo cryptoChannel.MessageID
- senderUsername string
- content []byte
- timestamp time.Time
- lease time.Duration
- round rounds.Round
+ channelID *id.ID
+ messageID cryptoChannel.MessageID
+ reactionTo cryptoChannel.MessageID
+ nickname string
+ content []byte
+ timestamp time.Time
+ lease time.Duration
+ round rounds.Round
}
type MockEvent struct {
+ uuid uint64
eventReceive
}
-func (m *MockEvent) UpdateSentStatus(messageID cryptoChannel.MessageID,
- status SentStatus) {
+func (m *MockEvent) getUUID() uint64 {
+ old := m.uuid
+ m.uuid++
+ return old
+}
+
+func (m *MockEvent) UpdateSentStatus(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
//TODO implement me
panic("implement me")
}
@@ -47,49 +55,53 @@ func (m *MockEvent) UpdateSentStatus(messageID cryptoChannel.MessageID,
func (*MockEvent) JoinChannel(channel *cryptoBroadcast.Channel) {}
func (*MockEvent) LeaveChannel(channelID *id.ID) {}
func (m *MockEvent) ReceiveMessage(channelID *id.ID, messageID cryptoChannel.MessageID,
- senderUsername string, text string,
- timestamp time.Time, lease time.Duration, round rounds.Round, status SentStatus) {
+ nickname, text string, identity cryptoChannel.Identity,
+ timestamp time.Time, lease time.Duration, round rounds.Round,
+ status SentStatus) uint64 {
m.eventReceive = eventReceive{
- channelID: channelID,
- messageID: messageID,
- reactionTo: cryptoChannel.MessageID{},
- senderUsername: senderUsername,
- content: []byte(text),
- timestamp: timestamp,
- lease: lease,
- round: round,
- }
+ channelID: channelID,
+ messageID: messageID,
+ reactionTo: cryptoChannel.MessageID{},
+ nickname: nickname,
+ content: []byte(text),
+ timestamp: timestamp,
+ lease: lease,
+ round: round,
+ }
+ return m.getUUID()
}
func (m *MockEvent) ReceiveReply(channelID *id.ID, messageID cryptoChannel.MessageID,
- replyTo cryptoChannel.MessageID, senderUsername string,
- text string, timestamp time.Time, lease time.Duration,
- round rounds.Round, status SentStatus) {
- fmt.Println(replyTo)
+ reactionTo cryptoChannel.MessageID, nickname, text string,
+ identity cryptoChannel.Identity, timestamp time.Time,
+ lease time.Duration, round rounds.Round, status SentStatus) uint64 {
+ fmt.Println(reactionTo)
m.eventReceive = eventReceive{
- channelID: channelID,
- messageID: messageID,
- reactionTo: replyTo,
- senderUsername: senderUsername,
- content: []byte(text),
- timestamp: timestamp,
- lease: lease,
- round: round,
- }
+ channelID: channelID,
+ messageID: messageID,
+ reactionTo: reactionTo,
+ nickname: nickname,
+ content: []byte(text),
+ timestamp: timestamp,
+ lease: lease,
+ round: round,
+ }
+ return m.getUUID()
}
func (m *MockEvent) ReceiveReaction(channelID *id.ID, messageID cryptoChannel.MessageID,
- reactionTo cryptoChannel.MessageID, senderUsername string,
- reaction string, timestamp time.Time, lease time.Duration,
- round rounds.Round, status SentStatus) {
+ reactionTo cryptoChannel.MessageID, nickname, reaction string,
+ identity cryptoChannel.Identity, timestamp time.Time,
+ lease time.Duration, round rounds.Round, status SentStatus) uint64 {
m.eventReceive = eventReceive{
- channelID: channelID,
- messageID: messageID,
- reactionTo: reactionTo,
- senderUsername: senderUsername,
- content: []byte(reaction),
- timestamp: timestamp,
- lease: lease,
- round: round,
- }
+ channelID: channelID,
+ messageID: messageID,
+ reactionTo: reactionTo,
+ nickname: nickname,
+ content: []byte(reaction),
+ timestamp: timestamp,
+ lease: lease,
+ round: round,
+ }
+ return m.getUUID()
}
func Test_initEvents(t *testing.T) {
@@ -181,31 +193,32 @@ func TestEvents_RegisterReceiveHandler(t *testing.T) {
}
type dummyMessageTypeHandler struct {
- triggered bool
- channelID *id.ID
- messageID cryptoChannel.MessageID
- messageType MessageType
- senderUsername string
- content []byte
- timestamp time.Time
- lease time.Duration
- round rounds.Round
+ triggered bool
+ channelID *id.ID
+ messageID cryptoChannel.MessageID
+ messageType MessageType
+ nickname string
+ content []byte
+ timestamp time.Time
+ lease time.Duration
+ round rounds.Round
}
-func (dmth *dummyMessageTypeHandler) dummyMessageTypeReceiveMessage(
- channelID *id.ID, messageID cryptoChannel.MessageID,
- messageType MessageType, senderUsername string, content []byte,
+func (dmth *dummyMessageTypeHandler) dummyMessageTypeReceiveMessage(channelID *id.ID,
+ messageID cryptoChannel.MessageID, messageType MessageType,
+ nickname string, content []byte, identity cryptoChannel.Identity,
timestamp time.Time, lease time.Duration, round rounds.Round,
- status SentStatus) {
+ status SentStatus) uint64 {
dmth.triggered = true
dmth.channelID = channelID
dmth.messageID = messageID
dmth.messageType = messageType
- dmth.senderUsername = senderUsername
+ dmth.nickname = nickname
dmth.content = content
dmth.timestamp = timestamp
dmth.lease = lease
dmth.round = round
+ return rand.Uint64()
}
func TestEvents_triggerEvents(t *testing.T) {
@@ -233,8 +246,10 @@ func TestEvents_triggerEvents(t *testing.T) {
r.Timestamps[states.QUEUED] = time.Now()
//call the trigger
- e.triggerEvent(chID, umi, receptionID.EphemeralIdentity{}, r, Delivered)
-
+ _, err = e.triggerEvent(chID, umi, time.Now(), receptionID.EphemeralIdentity{}, r, Delivered)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
//check that the event was triggered
if !dummy.triggered {
t.Errorf("The event was not triggered")
@@ -256,9 +271,9 @@ func TestEvents_triggerEvents(t *testing.T) {
dummy.messageType, mt)
}
- if dummy.senderUsername != umi.GetUserMessage().Username {
+ if dummy.nickname != umi.channelMessage.Nickname {
t.Errorf("The usernames do not match %s vs %s",
- dummy.senderUsername, umi.GetUserMessage().Username)
+ dummy.nickname, umi.channelMessage.Nickname)
}
if !bytes.Equal(dummy.content, umi.GetChannelMessage().Payload) {
@@ -290,7 +305,7 @@ func TestEvents_triggerEvents_noChannel(t *testing.T) {
dummy := &dummyMessageTypeHandler{}
//skip handler registration
- mt := MessageType(42)
+ mt := MessageType(1)
//craft the input for the event
chID := &id.ID{}
@@ -302,7 +317,10 @@ func TestEvents_triggerEvents_noChannel(t *testing.T) {
r.Timestamps[states.QUEUED] = time.Now()
//call the trigger
- e.triggerEvent(chID, umi, receptionID.EphemeralIdentity{}, r, Delivered)
+ _, err := e.triggerEvent(chID, umi, time.Now(), receptionID.EphemeralIdentity{}, r, Delivered)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
//check that the event was triggered
if dummy.triggered {
@@ -337,8 +355,11 @@ func TestEvents_triggerAdminEvents(t *testing.T) {
msgID := cryptoChannel.MakeMessageID(u.userMessage.Message)
//call the trigger
- e.triggerAdminEvent(chID, cm, msgID, receptionID.EphemeralIdentity{}, r,
+ _, err = e.triggerAdminEvent(chID, cm, time.Now(), msgID, receptionID.EphemeralIdentity{}, r,
Delivered)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
//check that the event was triggered
if !dummy.triggered {
@@ -361,14 +382,14 @@ func TestEvents_triggerAdminEvents(t *testing.T) {
dummy.messageType, mt)
}
- if dummy.senderUsername != AdminUsername {
+ if dummy.nickname != AdminUsername {
t.Errorf("The usernames do not match %s vs %s",
- dummy.senderUsername, AdminUsername)
+ dummy.nickname, AdminUsername)
}
if !bytes.Equal(dummy.content, cm.Payload) {
t.Errorf("The payloads do not match %s vs %s",
- dummy.senderUsername, cm.Payload)
+ dummy.content, cm.Payload)
}
if !withinMutationWindow(r.Timestamps[states.QUEUED], dummy.timestamp) {
@@ -394,7 +415,7 @@ func TestEvents_triggerAdminEvents_noChannel(t *testing.T) {
dummy := &dummyMessageTypeHandler{}
- mt := MessageType(42)
+ mt := MessageType(1)
//skip handler registration
//craft the input for the event
@@ -409,8 +430,11 @@ func TestEvents_triggerAdminEvents_noChannel(t *testing.T) {
msgID := cryptoChannel.MakeMessageID(u.userMessage.Message)
//call the trigger
- e.triggerAdminEvent(chID, cm, msgID, receptionID.EphemeralIdentity{}, r,
+ _, err := e.triggerAdminEvent(chID, cm, time.Now(), msgID, receptionID.EphemeralIdentity{}, r,
Delivered)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
//check that the event was triggered
if dummy.triggered {
@@ -440,7 +464,14 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
msgID := cryptoChannel.MakeMessageID(textMarshaled)
- senderUsername := "Alice"
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ senderNickname := "Alice"
ts := time.Now()
lease := 69 * time.Minute
@@ -449,8 +480,8 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
r.Timestamps[states.QUEUED] = time.Now()
//call the handler
- e.receiveTextMessage(chID, msgID, 0, senderUsername,
- textMarshaled, ts, lease, r, Delivered)
+ e.receiveTextMessage(chID, msgID, 0, senderNickname,
+ textMarshaled, pi.Identity, ts, lease, r, Delivered)
//check the results on the model
if !me.eventReceive.channelID.Cmp(chID) {
@@ -468,9 +499,9 @@ func TestEvents_receiveTextMessage_Message(t *testing.T) {
me.eventReceive.reactionTo)
}
- if me.eventReceive.senderUsername != senderUsername {
+ if me.eventReceive.nickname != senderNickname {
t.Errorf("SenderID propogate correctly, %s vs %s",
- me.eventReceive.senderUsername, senderUsername)
+ me.eventReceive.nickname, senderNickname)
}
if me.eventReceive.timestamp != ts {
@@ -521,9 +552,16 @@ func TestEvents_receiveTextMessage_Reply(t *testing.T) {
r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
r.Timestamps[states.QUEUED] = time.Now()
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
//call the handler
e.receiveTextMessage(chID, msgID, Text, senderUsername,
- textMarshaled, ts, lease, r, Delivered)
+ textMarshaled, pi.Identity, ts, lease, r, Delivered)
//check the results on the model
if !me.eventReceive.channelID.Cmp(chID) {
@@ -541,9 +579,9 @@ func TestEvents_receiveTextMessage_Reply(t *testing.T) {
"%s vs %s", me.eventReceive.reactionTo, replyMsgId)
}
- if me.eventReceive.senderUsername != senderUsername {
+ if me.eventReceive.nickname != senderUsername {
t.Errorf("SenderID propogate correctly, %s vs %s",
- me.eventReceive.senderUsername, senderUsername)
+ me.eventReceive.nickname, senderUsername)
}
if me.eventReceive.timestamp != ts {
@@ -594,9 +632,16 @@ func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
r.Timestamps[states.QUEUED] = time.Now()
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
//call the handler
e.receiveTextMessage(chID, msgID, 0, senderUsername,
- textMarshaled, ts, lease, r, Delivered)
+ textMarshaled, pi.Identity, ts, lease, r, Delivered)
//check the results on the model
if !me.eventReceive.channelID.Cmp(chID) {
@@ -614,9 +659,9 @@ func TestEvents_receiveTextMessage_Reply_BadReply(t *testing.T) {
me.eventReceive.reactionTo)
}
- if me.eventReceive.senderUsername != senderUsername {
+ if me.eventReceive.nickname != senderUsername {
t.Errorf("SenderID propogate correctly, %s vs %s",
- me.eventReceive.senderUsername, senderUsername)
+ me.eventReceive.nickname, senderUsername)
}
if me.eventReceive.timestamp != ts {
@@ -667,9 +712,16 @@ func TestEvents_receiveReaction(t *testing.T) {
r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
r.Timestamps[states.QUEUED] = time.Now()
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
//call the handler
e.receiveReaction(chID, msgID, 0, senderUsername,
- textMarshaled, ts, lease, r, Delivered)
+ textMarshaled, pi.Identity, ts, lease, r, Delivered)
//check the results on the model
if !me.eventReceive.channelID.Cmp(chID) {
@@ -687,9 +739,9 @@ func TestEvents_receiveReaction(t *testing.T) {
"%s vs %s", me.eventReceive.reactionTo, replyMsgId)
}
- if me.eventReceive.senderUsername != senderUsername {
+ if me.eventReceive.nickname != senderUsername {
t.Errorf("SenderID propogate correctly, %s vs %s",
- me.eventReceive.senderUsername, senderUsername)
+ me.eventReceive.nickname, senderUsername)
}
if me.eventReceive.timestamp != ts {
@@ -740,9 +792,16 @@ func TestEvents_receiveReaction_InvalidReactionMessageID(t *testing.T) {
r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
r.Timestamps[states.QUEUED] = time.Now()
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
//call the handler
e.receiveReaction(chID, msgID, 0, senderUsername,
- textMarshaled, ts, lease, r, Delivered)
+ textMarshaled, pi.Identity, ts, lease, r, Delivered)
//check the results on the model
if me.eventReceive.channelID != nil {
@@ -760,7 +819,7 @@ func TestEvents_receiveReaction_InvalidReactionMessageID(t *testing.T) {
"is bad")
}
- if me.eventReceive.senderUsername != "" {
+ if me.eventReceive.nickname != "" {
t.Errorf("SenderID propogated correctly when the reaction " +
"is bad")
}
@@ -803,9 +862,15 @@ func TestEvents_receiveReaction_InvalidReactionContent(t *testing.T) {
r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
r.Timestamps[states.QUEUED] = time.Now()
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
//call the handler
e.receiveReaction(chID, msgID, 0, senderUsername,
- textMarshaled, ts, lease, r, Delivered)
+ textMarshaled, pi.Identity, ts, lease, r, Delivered)
//check the results on the model
if me.eventReceive.channelID != nil {
@@ -823,7 +888,7 @@ func TestEvents_receiveReaction_InvalidReactionContent(t *testing.T) {
"is bad")
}
- if me.eventReceive.senderUsername != "" {
+ if me.eventReceive.nickname != "" {
t.Errorf("SenderID propogated correctly when the reaction " +
"is bad")
}
diff --git a/channels/joinedChannel_test.go b/channels/joinedChannel_test.go
index 2da31d171..262b3036c 100644
--- a/channels/joinedChannel_test.go
+++ b/channels/joinedChannel_test.go
@@ -23,6 +23,7 @@ import (
"gitlab.com/xx_network/crypto/csprng"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/id/ephemeral"
+ "math/rand"
"reflect"
"sort"
"strconv"
@@ -32,10 +33,22 @@ import (
// Tests that manager.store stores the channel list in the ekv.
func Test_manager_store(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
for i := 0; i < 10; i++ {
ch, _, err := newTestChannel("name_"+strconv.Itoa(i),
@@ -52,7 +65,7 @@ func Test_manager_store(t *testing.T) {
m.channels[*ch.ReceptionID] = &joinedChannel{b}
}
- err := m.store()
+ err = m.store()
if err != nil {
t.Errorf("Error storing channels: %+v", err)
}
@@ -66,10 +79,22 @@ func Test_manager_store(t *testing.T) {
// Tests that the manager.loadChannels loads all the expected channels from the
// ekv.
func Test_manager_loadChannels(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
expected := make([]*joinedChannel, 10)
@@ -95,7 +120,7 @@ func Test_manager_loadChannels(t *testing.T) {
expected[i] = jc
}
- err := m.store()
+ err = m.store()
if err != nil {
t.Errorf("Error storing channels: %+v", err)
}
@@ -126,10 +151,22 @@ func Test_manager_loadChannels(t *testing.T) {
// Tests that manager.addChannel adds the channel to the map and stores it in
// the kv.
func Test_manager_addChannel(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -159,10 +196,22 @@ func Test_manager_addChannel(t *testing.T) {
// Error path: tests that manager.addChannel returns ChannelAlreadyExistsErr
// when the channel was already added.
func Test_manager_addChannel_ChannelAlreadyExistsErr(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -183,10 +232,22 @@ func Test_manager_addChannel_ChannelAlreadyExistsErr(t *testing.T) {
// Tests the manager.removeChannel deletes the channel from the map.
func Test_manager_removeChannel(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -216,10 +277,22 @@ func Test_manager_removeChannel(t *testing.T) {
// Error path: tests that manager.removeChannel returns ChannelDoesNotExistsErr
// when the channel was never added.
func Test_manager_removeChannel_ChannelDoesNotExistsErr(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -236,10 +309,22 @@ func Test_manager_removeChannel_ChannelDoesNotExistsErr(t *testing.T) {
// Tests the manager.getChannel returns the expected channel.
func Test_manager_getChannel(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -265,10 +350,22 @@ func Test_manager_getChannel(t *testing.T) {
// Error path: tests that manager.getChannel returns ChannelDoesNotExistsErr
// when the channel was never added.
func Test_manager_getChannel_ChannelDoesNotExistsErr(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -286,10 +383,22 @@ func Test_manager_getChannel_ChannelDoesNotExistsErr(t *testing.T) {
// Tests that manager.getChannels returns all the channels that were added to
// the map.
func Test_manager_getChannels(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
expected := make([]*id.ID, 10)
@@ -353,10 +462,22 @@ func Test_joinedChannel_Store(t *testing.T) {
// Tests that loadJoinedChannel returns a joinedChannel from storage that
// matches the original.
func Test_loadJoinedChannel(t *testing.T) {
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), new(mockEventModel)).(*manager)
+ new(mockEventModel))
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -369,7 +490,7 @@ func Test_loadJoinedChannel(t *testing.T) {
}
loadedJc, err := loadJoinedChannel(ch.ReceptionID, m.kv, m.net, m.rng,
- m.name, m.events, m.broadcastMaker, func(messageID cryptoChannel.MessageID) bool {
+ m.events, m.broadcastMaker, func(messageID cryptoChannel.MessageID) bool {
return false
})
if err != nil {
@@ -486,8 +607,8 @@ type mockEventModel struct {
leftCh *id.ID
}
-func (m *mockEventModel) UpdateSentStatus(messageID cryptoChannel.MessageID,
- status SentStatus) {
+func (m *mockEventModel) UpdateSentStatus(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
//TODO implement me
panic("implement me")
}
@@ -498,14 +619,21 @@ func (m *mockEventModel) JoinChannel(c *cryptoBroadcast.Channel) {
func (m *mockEventModel) LeaveChannel(c *id.ID) {
m.leftCh = c
}
-func (m *mockEventModel) ReceiveMessage(*id.ID, cryptoChannel.MessageID, string,
- string, time.Time, time.Duration, rounds.Round, SentStatus) {
+func (m *mockEventModel) ReceiveMessage(channelID *id.ID, messageID cryptoChannel.MessageID,
+ nickname, text string, identity cryptoChannel.Identity,
+ timestamp time.Time, lease time.Duration, round rounds.Round,
+ status SentStatus) uint64 {
+ return 0
}
-func (m *mockEventModel) ReceiveReply(*id.ID, cryptoChannel.MessageID,
- cryptoChannel.MessageID, string, string, time.Time, time.Duration,
- rounds.Round, SentStatus) {
+func (m *mockEventModel) ReceiveReply(channelID *id.ID, messageID cryptoChannel.MessageID,
+ reactionTo cryptoChannel.MessageID, nickname, text string,
+ identity cryptoChannel.Identity, timestamp time.Time,
+ lease time.Duration, round rounds.Round, status SentStatus) uint64 {
+ return 0
}
-func (m *mockEventModel) ReceiveReaction(*id.ID, cryptoChannel.MessageID,
- cryptoChannel.MessageID, string, string, time.Time, time.Duration,
- rounds.Round, SentStatus) {
+func (m *mockEventModel) ReceiveReaction(channelID *id.ID, messageID cryptoChannel.MessageID,
+ reactionTo cryptoChannel.MessageID, nickname, reaction string,
+ identity cryptoChannel.Identity, timestamp time.Time,
+ lease time.Duration, round rounds.Round, status SentStatus) uint64 {
+ return 0
}
diff --git a/channels/manager_test.go b/channels/manager_test.go
index 29d283f4b..3aa460df1 100644
--- a/channels/manager_test.go
+++ b/channels/manager_test.go
@@ -11,10 +11,12 @@ import (
"fmt"
"gitlab.com/elixxir/client/broadcast"
"gitlab.com/elixxir/client/storage/versioned"
+ cryptoChannel "gitlab.com/elixxir/crypto/channel"
"gitlab.com/elixxir/crypto/fastRNG"
"gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/crypto/csprng"
"gitlab.com/xx_network/primitives/id"
+ "math/rand"
"os"
"sync"
"testing"
@@ -33,10 +35,22 @@ func TestMain(m *testing.M) {
func TestManager_JoinChannel(t *testing.T) {
mem := &mockEventModel{}
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), mem).(*manager)
+ mem)
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
@@ -64,10 +78,22 @@ func TestManager_JoinChannel(t *testing.T) {
func TestManager_LeaveChannel(t *testing.T) {
mem := &mockEventModel{}
- m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ mFace, err := NewManager(pi, versioned.NewKV(ekv.MakeMemstore()),
new(mockBroadcastClient),
fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
- new(mockNameService), mem).(*manager)
+ mem)
+ if err != nil {
+ t.Errorf(err.Error())
+ }
+
+ m := mFace.(*manager)
ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
if err != nil {
diff --git a/channels/messages_test.go b/channels/messages_test.go
index cdd9a43fa..5bd10e15b 100644
--- a/channels/messages_test.go
+++ b/channels/messages_test.go
@@ -89,10 +89,7 @@ func TestUserMessageInternal_GetUserMessage(t *testing.T) {
received := internal.GetUserMessage()
if !reflect.DeepEqual(received.Message, usrMsg.Message) ||
- received.Username != usrMsg.Username ||
- received.UsernameLease != usrMsg.UsernameLease ||
!reflect.DeepEqual(received.Signature, usrMsg.Signature) ||
- !reflect.DeepEqual(received.ValidationSignature, usrMsg.ValidationSignature) ||
!reflect.DeepEqual(received.ECCPublicKey, usrMsg.ECCPublicKey) {
t.Fatalf("GetUserMessage did not return expected data."+
"\nExpected: %v"+
@@ -118,7 +115,7 @@ func TestUserMessageInternal_GetMessageID(t *testing.T) {
// it would be good to know when this changes. If this test breaks, report it,
// but it should be safe to update the expected
func TestUserMessageInternal_GetMessageID_Consistency(t *testing.T) {
- expected := "ChMsgID-cfw4O6M47N9pqdtTcQjm/SSVqehTPGQd7cAMrNP9bcc="
+ expected := "ChMsgID-s425CTIAcKxvhUEZNr6Dk1g6rrOOpzKOS9L97OzLJ2w="
internal, _, _ := builtTestUMI(t, 7)
@@ -137,6 +134,7 @@ func builtTestUMI(t *testing.T, mt MessageType) (*userMessageInternal, *UserMess
RoundID: 42,
PayloadType: uint32(mt),
Payload: []byte("ban_badUSer"),
+ Nickname: "paul",
}
serialized, err := proto.Marshal(channelMsg)
@@ -145,12 +143,9 @@ func builtTestUMI(t *testing.T, mt MessageType) (*userMessageInternal, *UserMess
}
usrMsg := &UserMessage{
- Message: serialized,
- ValidationSignature: []byte("sig"),
- Signature: []byte("sig2"),
- Username: "hunter2",
- ECCPublicKey: []byte("key"),
- UsernameLease: 666,
+ Message: serialized,
+ Signature: []byte("sig2"),
+ ECCPublicKey: []byte("key"),
}
internal, _ := newUserMessageInternal(usrMsg)
diff --git a/channels/sendTracker_test.go b/channels/sendTracker_test.go
index 0c8823952..fdcd9f86c 100644
--- a/channels/sendTracker_test.go
+++ b/channels/sendTracker_test.go
@@ -43,11 +43,20 @@ func (mc *mockClient) RemoveHealthCallback(uint64) {}
// Test MessageReceive basic logic
func TestSendTracker_MessageReceive(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
- trigger := func(chID *id.ID, umi *userMessageInternal,
- receptionID receptionID.EphemeralIdentity, round rounds.Round, status SentStatus) {
+ uuidNum := uint64(0)
+ trigger := func(chID *id.ID, umi *userMessageInternal, ts time.Time,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round,
+ status SentStatus) (uint64, error) {
+ oldUUID := uuidNum
+ uuidNum++
+ return oldUUID, nil
}
- st := loadSendTracker(&mockClient{}, kv, trigger, nil, nil)
+ updateStatus := func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
+ }
+
+ st := loadSendTracker(&mockClient{}, kv, trigger, nil, updateStatus)
mid := cryptoChannel.MakeMessageID([]byte("hello"))
process := st.MessageReceive(mid)
@@ -57,35 +66,44 @@ func TestSendTracker_MessageReceive(t *testing.T) {
cid := id.NewIdFromString("channel", id.User, t)
rid := id.Round(2)
- st.send(cid, &userMessageInternal{
+ uuid, err := st.denotePendingSend(cid, &userMessageInternal{
userMessage: &UserMessage{},
channelMessage: &ChannelMessage{
Lease: time.Now().UnixNano(),
RoundID: uint64(rid),
PayloadType: 0,
Payload: []byte("hello"),
- },
- messageID: mid,
- }, rounds.Round{
+ }})
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ err = st.send(uuid, mid, rounds.Round{
ID: rid,
State: 1,
})
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
process = st.MessageReceive(mid)
if !process {
t.Fatalf("Did not receive expected result from MessageReceive")
}
cid2 := id.NewIdFromString("channel two", id.User, t)
- st.send(cid2, &userMessageInternal{
+ uuid2, err := st.denotePendingSend(cid2, &userMessageInternal{
userMessage: &UserMessage{},
channelMessage: &ChannelMessage{
Lease: time.Now().UnixNano(),
RoundID: uint64(rid),
PayloadType: 0,
Payload: []byte("hello again"),
- },
- messageID: mid,
- }, rounds.Round{
+ }})
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ err = st.send(uuid2, mid, rounds.Round{
ID: rid,
State: 1,
})
@@ -102,26 +120,39 @@ func TestSendTracker_sendAdmin(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
- adminTrigger := func(chID *id.ID, cm *ChannelMessage,
+ adminTrigger := func(chID *id.ID, cm *ChannelMessage, ts time.Time,
messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }
+
+ updateStatus := func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
triggerCh <- true
}
- st := loadSendTracker(&mockClient{}, kv, nil, adminTrigger, nil)
+ st := loadSendTracker(&mockClient{}, kv, nil, adminTrigger, updateStatus)
cid := id.NewIdFromString("channel", id.User, t)
mid := cryptoChannel.MakeMessageID([]byte("hello"))
rid := id.Round(2)
- st.sendAdmin(cid, &ChannelMessage{
+ uuid, err := st.denotePendingAdminSend(cid, &ChannelMessage{
Lease: 0,
RoundID: uint64(rid),
PayloadType: 0,
Payload: []byte("hello"),
- }, mid, rounds.Round{
+ })
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ err = st.sendAdmin(uuid, mid, rounds.Round{
ID: rid,
State: 2,
})
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
timeout := time.NewTicker(time.Second * 5)
select {
@@ -157,17 +188,22 @@ func TestSendTracker_send(t *testing.T) {
triggerCh := make(chan bool)
kv := versioned.NewKV(ekv.MakeMemstore())
- trigger := func(chID *id.ID, umi *userMessageInternal,
- receptionID receptionID.EphemeralIdentity, round rounds.Round, status SentStatus) {
+ trigger := func(chID *id.ID, umi *userMessageInternal, ts time.Time,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }
+
+ updateStatus := func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
triggerCh <- true
}
- st := loadSendTracker(&mockClient{}, kv, trigger, nil, nil)
+ st := loadSendTracker(&mockClient{}, kv, trigger, nil, updateStatus)
cid := id.NewIdFromString("channel", id.User, t)
mid := cryptoChannel.MakeMessageID([]byte("hello"))
rid := id.Round(2)
- st.send(cid, &userMessageInternal{
+ uuid, err := st.denotePendingSend(cid, &userMessageInternal{
userMessage: &UserMessage{},
channelMessage: &ChannelMessage{
Lease: 0,
@@ -176,10 +212,18 @@ func TestSendTracker_send(t *testing.T) {
Payload: []byte("hello"),
},
messageID: mid,
- }, rounds.Round{
+ })
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ err = st.send(uuid, mid, rounds.Round{
ID: rid,
State: 2,
})
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
timeout := time.NewTicker(time.Second * 5)
select {
@@ -232,18 +276,22 @@ func TestSendTracker_load_store(t *testing.T) {
func TestRoundResult_callback(t *testing.T) {
kv := versioned.NewKV(ekv.MakeMemstore())
triggerCh := make(chan bool)
- update := func(messageID cryptoChannel.MessageID, status SentStatus) {
+ update := func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
triggerCh <- true
}
- trigger := func(chID *id.ID, umi *userMessageInternal,
- receptionID receptionID.EphemeralIdentity, round rounds.Round, status SentStatus) {
+ trigger := func(chID *id.ID, umi *userMessageInternal, ts time.Time,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round,
+ status SentStatus) (uint64, error) {
+ return 0, nil
}
+
st := loadSendTracker(&mockClient{}, kv, trigger, nil, update)
cid := id.NewIdFromString("channel", id.User, t)
mid := cryptoChannel.MakeMessageID([]byte("hello"))
rid := id.Round(2)
- st.send(cid, &userMessageInternal{
+ uuid, err := st.denotePendingSend(cid, &userMessageInternal{
userMessage: &UserMessage{},
channelMessage: &ChannelMessage{
Lease: 0,
@@ -252,7 +300,12 @@ func TestRoundResult_callback(t *testing.T) {
Payload: []byte("hello"),
},
messageID: mid,
- }, rounds.Round{
+ })
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
+ err = st.send(uuid, mid, rounds.Round{
ID: rid,
State: 2,
})
diff --git a/channels/send_test.go b/channels/send_test.go
index 5a6e1999c..4312a7a16 100644
--- a/channels/send_test.go
+++ b/channels/send_test.go
@@ -18,6 +18,7 @@ import (
"gitlab.com/elixxir/crypto/rsa"
"gitlab.com/elixxir/ekv"
"gitlab.com/xx_network/crypto/csprng"
+ "math/rand"
"testing"
"time"
@@ -141,18 +142,33 @@ func TestSendGeneric(t *testing.T) {
nameService := new(mockNameService)
nameService.validChMsg = true
+ rng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(rng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
m := &manager{
+ me: pi,
channels: make(map[id.ID]*joinedChannel),
- name: nameService,
+ nicknameManager: &nicknameManager{
+ byChannel: make(map[id.ID]string),
+ kv: nil,
+ },
st: loadSendTracker(&mockBroadcastClient{},
versioned.NewKV(ekv.MakeMemstore()), func(chID *id.ID,
- umi *userMessageInternal,
+ umi *userMessageInternal, ts time.Time,
receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(chID *id.ID, cm *ChannelMessage,
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(chID *id.ID, cm *ChannelMessage, ts time.Time,
messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(messageID cryptoChannel.MessageID, status SentStatus) {}),
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
+ }),
}
channelID := new(id.ID)
@@ -212,21 +228,33 @@ func TestSendGeneric(t *testing.T) {
func TestAdminGeneric(t *testing.T) {
- nameService := new(mockNameService)
- nameService.validChMsg = true
+ prng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(prng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
m := &manager{
channels: make(map[id.ID]*joinedChannel),
- name: nameService,
+ nicknameManager: &nicknameManager{
+ byChannel: make(map[id.ID]string),
+ kv: nil,
+ },
+ me: pi,
st: loadSendTracker(&mockBroadcastClient{},
versioned.NewKV(ekv.MakeMemstore()), func(chID *id.ID,
- umi *userMessageInternal,
+ umi *userMessageInternal, ts time.Time,
receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(chID *id.ID, cm *ChannelMessage,
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(chID *id.ID, cm *ChannelMessage, ts time.Time,
messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(messageID cryptoChannel.MessageID, status SentStatus) {}),
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
+ }),
}
messageType := Text
@@ -289,18 +317,33 @@ func TestSendMessage(t *testing.T) {
nameService := new(mockNameService)
nameService.validChMsg = true
+ prng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(prng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+
m := &manager{
+ me: pi,
channels: make(map[id.ID]*joinedChannel),
- name: nameService,
+ nicknameManager: &nicknameManager{
+ byChannel: make(map[id.ID]string),
+ kv: nil,
+ },
st: loadSendTracker(&mockBroadcastClient{},
versioned.NewKV(ekv.MakeMemstore()), func(chID *id.ID,
- umi *userMessageInternal,
+ umi *userMessageInternal, ts time.Time,
receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(chID *id.ID, cm *ChannelMessage,
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(chID *id.ID, cm *ChannelMessage, ts time.Time,
messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(messageID cryptoChannel.MessageID, status SentStatus) {}),
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
+ }),
}
channelID := new(id.ID)
@@ -368,21 +411,33 @@ func TestSendMessage(t *testing.T) {
func TestSendReply(t *testing.T) {
- nameService := new(mockNameService)
- nameService.validChMsg = true
+ prng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(prng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
m := &manager{
+ me: pi,
channels: make(map[id.ID]*joinedChannel),
- name: nameService,
+ nicknameManager: &nicknameManager{
+ byChannel: make(map[id.ID]string),
+ kv: nil,
+ },
st: loadSendTracker(&mockBroadcastClient{},
versioned.NewKV(ekv.MakeMemstore()), func(chID *id.ID,
- umi *userMessageInternal,
+ umi *userMessageInternal, ts time.Time,
receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(chID *id.ID, cm *ChannelMessage,
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(chID *id.ID, cm *ChannelMessage, ts time.Time,
messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(messageID cryptoChannel.MessageID, status SentStatus) {}),
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
+ }),
}
channelID := new(id.ID)
@@ -450,21 +505,33 @@ func TestSendReply(t *testing.T) {
func TestSendReaction(t *testing.T) {
- nameService := new(mockNameService)
- nameService.validChMsg = true
+ prng := rand.New(rand.NewSource(64))
+
+ pi, err := cryptoChannel.GenerateIdentity(prng)
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
m := &manager{
+ me: pi,
+ nicknameManager: &nicknameManager{
+ byChannel: make(map[id.ID]string),
+ kv: nil,
+ },
channels: make(map[id.ID]*joinedChannel),
- name: nameService,
st: loadSendTracker(&mockBroadcastClient{},
versioned.NewKV(ekv.MakeMemstore()), func(chID *id.ID,
- umi *userMessageInternal,
+ umi *userMessageInternal, ts time.Time,
receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(chID *id.ID, cm *ChannelMessage,
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(chID *id.ID, cm *ChannelMessage, ts time.Time,
messageID cryptoChannel.MessageID, receptionID receptionID.EphemeralIdentity,
- round rounds.Round, status SentStatus) {
- }, func(messageID cryptoChannel.MessageID, status SentStatus) {}),
+ round rounds.Round, status SentStatus) (uint64, error) {
+ return 0, nil
+ }, func(uuid uint64, messageID cryptoChannel.MessageID,
+ timestamp time.Time, round rounds.Round, status SentStatus) {
+ }),
}
channelID := new(id.ID)
diff --git a/channels/userListener_test.go b/channels/userListener_test.go
index d58d540ff..143ebfeb4 100644
--- a/channels/userListener_test.go
+++ b/channels/userListener_test.go
@@ -34,7 +34,8 @@ type triggerEventDummy struct {
}
func (ted *triggerEventDummy) triggerEvent(chID *id.ID, umi *userMessageInternal,
- receptionID receptionID.EphemeralIdentity, round rounds.Round, sent SentStatus) {
+ ts time.Time, receptionID receptionID.EphemeralIdentity, round rounds.Round,
+ sent SentStatus) (uint64, error) {
ted.gotData = true
ted.chID = chID
@@ -42,6 +43,8 @@ func (ted *triggerEventDummy) triggerEvent(chID *id.ID, umi *userMessageInternal
ted.receptionID = receptionID
ted.round = round
ted.msgID = umi.GetMessageID()
+
+ return 0, nil
}
// Tests the happy path
@@ -78,12 +81,9 @@ func TestUserListener_Listen(t *testing.T) {
ns := &mockNameService{validChMsg: true}
um := &UserMessage{
- Message: cmSerial,
- ValidationSignature: []byte("Not checked in test"),
- Signature: sig,
- Username: ns.GetUsername(),
- ECCPublicKey: pub,
- UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ Message: cmSerial,
+ Signature: sig,
+ ECCPublicKey: pub,
}
umSerial, err := proto.Marshal(um)
@@ -166,143 +166,9 @@ func TestUserListener_Listen_BadUserSig(t *testing.T) {
ns := &mockNameService{validChMsg: true}
um := &UserMessage{
- Message: cmSerial,
- ValidationSignature: []byte("Not checked in test"),
- Signature: sig,
- Username: ns.GetUsername(),
- ECCPublicKey: pub,
- UsernameLease: time.Now().Add(time.Hour).UnixNano(),
- }
-
- umSerial, err := proto.Marshal(um)
- if err != nil {
- t.Fatalf("Failed to marshal proto: %+v", err)
- }
-
- //build the listener
- dummy := &triggerEventDummy{}
-
- al := userListener{
- chID: chID,
- name: ns,
- trigger: dummy.triggerEvent,
- checkSent: func(messageID cryptoChannel.MessageID) bool { return false },
- }
-
- //call the listener
- al.Listen(umSerial, receptionID.EphemeralIdentity{}, r)
-
- //check the results
- if dummy.gotData {
- t.Fatalf("Data returned after invalid listen")
- }
-}
-
-//tests that the message is rejected when the validation signature cannot be
-//validated
-func TestUserListener_Listen_BadValidSig(t *testing.T) {
-
- //build inputs
- chID := &id.ID{}
- chID[0] = 1
-
- r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
- r.Timestamps[states.QUEUED] = time.Now()
-
- rng := rand.New(rand.NewSource(42))
- pub, priv, err := ed25519.GenerateKey(rng)
- if err != nil {
- t.Fatalf("failed to generate ed25519 keypair, cant run test")
- }
-
- cm := &ChannelMessage{
- Lease: int64(time.Hour),
- RoundID: uint64(r.ID),
- PayloadType: 42,
- Payload: []byte("blarg"),
- }
-
- cmSerial, err := proto.Marshal(cm)
- if err != nil {
- t.Fatalf("Failed to marshal proto: %+v", err)
- }
-
- sig := ed25519.Sign(priv, cmSerial)
- //make the signature not validate
- ns := &mockNameService{validChMsg: false}
-
- um := &UserMessage{
- Message: cmSerial,
- ValidationSignature: []byte("Not checked in test"),
- Signature: sig,
- Username: ns.GetUsername(),
- ECCPublicKey: pub,
- UsernameLease: time.Now().Add(time.Hour).UnixNano(),
- }
-
- umSerial, err := proto.Marshal(um)
- if err != nil {
- t.Fatalf("Failed to marshal proto: %+v", err)
- }
-
- //build the listener
- dummy := &triggerEventDummy{}
-
- al := userListener{
- chID: chID,
- name: ns,
- trigger: dummy.triggerEvent,
- checkSent: func(messageID cryptoChannel.MessageID) bool { return false },
- }
-
- //call the listener
- al.Listen(umSerial, receptionID.EphemeralIdentity{}, r)
-
- //check the results
- if dummy.gotData {
- t.Fatalf("Data returned after invalid listen")
- }
-}
-
-//tests that the message is rejected when the username timestamp is not valid
-func TestUserListener_Listen_BadUnameTs(t *testing.T) {
-
- //build inputs
- chID := &id.ID{}
- chID[0] = 1
-
- r := rounds.Round{ID: 420, Timestamps: make(map[states.Round]time.Time)}
- r.Timestamps[states.QUEUED] = time.Now()
-
- rng := rand.New(rand.NewSource(42))
- pub, priv, err := ed25519.GenerateKey(rng)
- if err != nil {
- t.Fatalf("failed to generate ed25519 keypair, cant run test")
- }
-
- cm := &ChannelMessage{
- Lease: int64(time.Hour),
- RoundID: uint64(r.ID),
- PayloadType: 42,
- Payload: []byte("blarg"),
- }
-
- cmSerial, err := proto.Marshal(cm)
- if err != nil {
- t.Fatalf("Failed to marshal proto: %+v", err)
- }
-
- sig := ed25519.Sign(priv, cmSerial)
- ns := &mockNameService{validChMsg: true}
-
- um := &UserMessage{
- Message: cmSerial,
- ValidationSignature: []byte("Not checked in test"),
- Signature: sig,
- Username: ns.GetUsername(),
- ECCPublicKey: pub,
- //make the username lease invalid
- UsernameLease: 42,
+ Message: cmSerial,
+ Signature: sig,
+ ECCPublicKey: pub,
}
umSerial, err := proto.Marshal(um)
@@ -363,12 +229,9 @@ func TestUserListener_Listen_BadRound(t *testing.T) {
ns := &mockNameService{validChMsg: true}
um := &UserMessage{
- Message: cmSerial,
- ValidationSignature: []byte("Not checked in test"),
- Signature: sig,
- Username: ns.GetUsername(),
- ECCPublicKey: pub,
- UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ Message: cmSerial,
+ Signature: sig,
+ ECCPublicKey: pub,
}
umSerial, err := proto.Marshal(um)
@@ -461,12 +324,9 @@ func TestUserListener_Listen_BadSizedBroadcast(t *testing.T) {
ns := &mockNameService{validChMsg: true}
um := &UserMessage{
- Message: cmSerial,
- ValidationSignature: []byte("Not checked in test"),
- Signature: sig,
- Username: ns.GetUsername(),
- ECCPublicKey: pub,
- UsernameLease: time.Now().Add(time.Hour).UnixNano(),
+ Message: cmSerial,
+ Signature: sig,
+ ECCPublicKey: pub,
}
umSerial, err := proto.Marshal(um)
--
GitLab