finish group chat tests

groupChat/manager.go

@@ -44,6 +44,7 @@ type GroupCmix interface {
 		response message.Processor)
 	DeleteService(clientID *id.ID, toDelete message.Service,
 		processor message.Processor)
+	GetMaxMessageLength() int
 }
 
 // GroupE2e is a subset of the e2e.Handler interface containing only the methods needed by GroupChat

groupChat/receive.go

@@ -38,7 +38,6 @@ type receptionProcessor struct {
 // Process incoming group chat messages
 func (p *receptionProcessor) Process(message format.Message, receptionID receptionID.EphemeralIdentity, round rounds.Round) {
 	jww.TRACE.Print("Group message reception received cMix message.")
-
 	// Attempt to read the message
 	roundTimestamp := round.Timestamps[states.QUEUED]
 
@@ -117,7 +116,6 @@ func getCryptKey(key group.Key, salt [group.SaltLen]byte, mac, payload []byte,
 
 	// Compute the current epoch
 	epoch := group.ComputeEpoch(roundTimestamp)
-
 	for _, dhKey := range dhKeys {
 
 		// Create a key with the correct epoch

groupChat/receiveRequest.go

@@ -89,7 +89,7 @@ func (m *Manager) readRequest(msg receive.Message) (gs.Group, error) {
 
 	// Generate the DH keys with each group member
 	privKey := partner.GetMyOriginPrivateKey()
-	dkl := gs.GenerateDhKeyList(m.gs.GetUser().ID, privKey, membership, m.grp)
+	dkl := gs.GenerateDhKeyList(m.receptionId, privKey, membership, m.grp)
 
 	// Restore the original public key for the leader so that the membership
 	// digest generated later is correct

groupChat/receiveRequest_test.go

@@ -66,7 +66,7 @@ func TestRequestListener_Hear(t *testing.T) {
 	_, _ = m.e2e.AddPartner(
 		g.Members[0].ID,
 		g.Members[0].DhKey,
-		m.grp.NewInt(2),
+		m.e2e.GetHistoricalDHPrivkey(),
 		theirSIDHPubKey, mySIDHPrivKey,
 		session.GetDefaultParams(),
 		session.GetDefaultParams(),
@@ -165,7 +165,7 @@ func TestManager_readRequest(t *testing.T) {
 	_, _ = m.e2e.AddPartner(
 		g.Members[0].ID,
 		g.Members[0].DhKey,
-		m.grp.NewInt(2),
+		m.e2e.GetHistoricalDHPrivkey(),
 		theirSIDHPubKey, mySIDHPrivKey,
 		session.GetDefaultParams(),
 		session.GetDefaultParams(),

groupChat/send.go

@@ -27,7 +27,6 @@ import (
 const (
 	newCmixMsgErr     = "failed to generate cMix messages for group chat: %+v"
 	sendManyCmixErr   = "failed to send group chat message from member %s to group %s: %+v"
-	newCmixErr        = "failed to generate cMix message for member %d with ID %s in group %s: %+v"
 	messageLenErr     = "message length %d is greater than maximum message space %d"
 	newNoGroupErr     = "failed to create message for group %s that cannot be found"
 	newKeyErr         = "failed to generate key for encrypting group payload"
@@ -94,7 +93,7 @@ func (m *Manager) newMessages(g gs.Group, msg []byte, timestamp time.Time) (
 		}
 
 		// Add cMix message to list
-		cMixMsg, err := newCmixMsg(g, msg, timestamp, member, rng, m.receptionId, m.grp)
+		cMixMsg, err := newCmixMsg(g, msg, timestamp, member, rng, m.receptionId, m.services.GetMaxMessageLength())
 		if err != nil {
 			return nil, err
 		}
@@ -106,7 +105,7 @@ func (m *Manager) newMessages(g gs.Group, msg []byte, timestamp time.Time) (
 
 // newCmixMsg generates a new cMix message to be sent to a group member.
 func newCmixMsg(g gs.Group, msg []byte, timestamp time.Time,
-	mem group.Member, rng io.Reader, senderId *id.ID, grp *cyclic.Group) (cmix.TargetedCmixMessage, error) {
+	mem group.Member, rng io.Reader, senderId *id.ID, maxCmixMessageSize int) (cmix.TargetedCmixMessage, error) {
 
 	// Initialize targeted message
 	cmixMsg := cmix.TargetedCmixMessage{
@@ -119,7 +118,7 @@ func newCmixMsg(g gs.Group, msg []byte, timestamp time.Time,
 	}
 
 	// Create three message layers
-	pubMsg, intlMsg, err := newMessageParts(grp.GetP().ByteLen())
+	pubMsg, intlMsg, err := newMessageParts(maxCmixMessageSize)
 	if err != nil {
 		return cmixMsg, err
 	}

groupChat/sendRequests.go

@@ -118,7 +118,7 @@ func (m Manager) sendRequest(memberID *id.ID, request []byte) ([]id.Round, error
 	p.LastServiceTag = catalog.GroupRq
 	p.CMIX.DebugTag = "group.Request"
 
-	rounds, _, _, err := m.e2e.SendE2E(catalog.GroupCreationRequest, m.receptionId, request, p)
+	rounds, _, _, err := m.e2e.SendE2E(catalog.GroupCreationRequest, memberID, request, p)
 	if err != nil {
 		return nil, errors.Errorf(sendE2eErr, memberID, err)
 	}

groupChat/send_test.go

@@ -10,11 +10,12 @@ package groupChat
 import (
 	"bytes"
 	"encoding/base64"
-	"gitlab.com/elixxir/client/cmix/rounds"
 	"gitlab.com/elixxir/client/cmix/identity/receptionID"
+	"gitlab.com/elixxir/client/cmix/rounds"
 	gs "gitlab.com/elixxir/client/groupChat/groupStore"
 	"gitlab.com/elixxir/crypto/group"
 	"gitlab.com/elixxir/primitives/format"
+	"gitlab.com/elixxir/primitives/states"
 	"gitlab.com/xx_network/primitives/id"
 	"gitlab.com/xx_network/primitives/netTime"
 	"math/rand"
@@ -50,8 +51,10 @@ func TestManager_Send(t *testing.T) {
 		t.Error("No group cMix messages received.")
 	}
 
+	timestamps := make(map[states.Round]time.Time)
+	timestamps[states.QUEUED] = netTime.Now().Round(0)
 	for _, msg := range messages {
-		reception.Process(msg, receptionID.EphemeralIdentity{}, rounds.Round{ID: roundId})
+		reception.Process(msg, receptionID.EphemeralIdentity{}, rounds.Round{ID: roundId, Timestamps: timestamps})
 		select {
 		case result := <-receiveChan:
 			if !result.SenderID.Cmp(m.receptionId) {
@@ -70,26 +73,13 @@ func TestManager_Send(t *testing.T) {
 	}
 }
 
-// Error path: an error is returned when Manager.neCmixMsg returns an error.
-func TestGroup_newMessages_NewCmixMsgError(t *testing.T) {
-	expectedErr := strings.SplitN(newCmixErr, "%", 2)[0]
-	prng := rand.New(rand.NewSource(42))
-	m, g := newTestManager(prng, t)
-
-	_, err := m.newMessages(g, make([]byte, 1000), netTime.Now())
-	if err == nil || !strings.Contains(err.Error(), expectedErr) {
-		t.Errorf("newMessages() failed to return the expected error."+
-			"\nexpected: %s\nreceived: %+v", expectedErr, err)
-	}
-}
-
 // Error path: reader returns an error.
 func TestGroup_newCmixMsg_SaltReaderError(t *testing.T) {
 	expectedErr := strings.SplitN(saltReadErr, "%", 2)[0]
-	m := &Manager{}
+	m, _ := newTestManager(rand.New(rand.NewSource(42)), t)
 
-	_, err := newCmixMsg(gs.Group{},
-		[]byte{}, time.Time{}, group.Member{}, strings.NewReader(""), m.receptionId, m.grp)
+	_, err := newCmixMsg(gs.Group{ID: id.NewIdFromString("test", id.User, t)},
+		[]byte{}, time.Time{}, group.Member{}, strings.NewReader(""), m.receptionId, m.services.GetMaxMessageLength())
 	if err == nil || !strings.Contains(err.Error(), expectedErr) {
 		t.Errorf("newCmixMsg() failed to return the expected error"+
 			"\nexpected: %s\nreceived: %+v", expectedErr, err)
@@ -102,15 +92,15 @@ func TestGroup_newCmixMsg_InternalMsgSizeError(t *testing.T) {
 
 	// Create new test Manager and Group
 	prng := rand.New(rand.NewSource(42))
-	m, g := newTestManager(prng, t)
+	m, g := newTestManagerWithStore(prng, 10, 0, nil, nil, t)
 
 	// Create test parameters
-	testMsg := make([]byte, 341)
+	testMsg := make([]byte, 1500)
 	mem := group.Member{ID: id.NewIdFromString("memberID", id.User, t)}
 
 	// Create cMix message
 	prng = rand.New(rand.NewSource(42))
-	_, err := newCmixMsg(g, testMsg, netTime.Now(), mem, prng, m.receptionId, m.grp)
+	_, err := newCmixMsg(g, testMsg, netTime.Now(), mem, prng, m.receptionId, m.services.GetMaxMessageLength())
 	if err == nil || !strings.Contains(err.Error(), expectedErr) {
 		t.Errorf("newCmixMsg() failed to return the expected error"+
 			"\nexpected: %s\nreceived: %+v", expectedErr, err)

groupChat/utils_test.go

@@ -55,7 +55,7 @@ func newTestManager(rng *rand.Rand, t *testing.T) (*Manager, gs.Group) {
 	}
 
 	g := newTestGroupWithUser(m.grp, user.ID, user.DhKey,
-		randCycInt(rng), rng, t)
+		m.e2e.GetHistoricalDHPrivkey(), rng, t)
 	gStore, err := gs.NewStore(versioned.NewKV(make(ekv.Memstore)), user)
 	if err != nil {
 		t.Fatalf("Failed to create new group store: %+v", err)
@@ -78,7 +78,13 @@ func newTestManagerWithStore(rng *rand.Rand, numGroups int, sendErr int,
 		requestFunc: requestFunc,
 		receiveFunc: receiveFunc,
 		services:    newTestNetworkManager(sendErr, t),
-		e2e:         newTestE2eManager(randCycInt(rng)),
+		e2e: &testE2eManager{
+			e2eMessages: []testE2eMessage{},
+			sendErr:     sendErr,
+			grp:         getGroup(),
+			dhPubKey:    randCycInt(rng),
+			partners:    make(map[id.ID]partner.Manager),
+		},
 	}
 	user := group.Member{
 		ID:    m.receptionId,
@@ -220,6 +226,7 @@ func newTestNetworkManager(sendErr int, t *testing.T) GroupCmix {
 	return &testNetworkManager{
 		receptionMessages: [][]format.Message{},
 		sendMessages:      [][]cmix.TargetedCmixMessage{},
+		grp:               getGroup(),
 		sendErr:           sendErr,
 	}
 }
@@ -311,9 +318,14 @@ type testNetworkManager struct {
 	sendMessages      [][]cmix.TargetedCmixMessage
 	errSkip           int
 	sendErr           int
+	grp               *cyclic.Group
 	sync.RWMutex
 }
 
+func (tnm *testNetworkManager) GetMaxMessageLength() int {
+	return format.NewMessage(tnm.grp.GetP().ByteLen()).ContentsSize()
+}
+
 func (tnm *testNetworkManager) SendMany(messages []cmix.TargetedCmixMessage, p cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
 	if tnm.sendErr == 1 {
 		return 0, nil, errors.New("SendManyCMIX error")
@@ -326,7 +338,7 @@ func (tnm *testNetworkManager) SendMany(messages []cmix.TargetedCmixMessage, p c
 
 	receiveMessages := []format.Message{}
 	for _, msg := range messages {
-		receiveMsg := format.Message{}
+		receiveMsg := format.NewMessage(tnm.grp.GetP().ByteLen())
 		receiveMsg.SetMac(msg.Mac)
 		receiveMsg.SetContents(msg.Payload)
 		receiveMsg.SetKeyFP(msg.Fingerprint)