fix more group chat tests

e2e/ratchet/partner/utils.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
+package partner
+
+import (
+	"github.com/cloudflare/circl/dh/sidh"
+	"gitlab.com/elixxir/client/cmix/message"
+	"gitlab.com/elixxir/client/e2e/ratchet/partner/session"
+	"gitlab.com/elixxir/crypto/contact"
+	"gitlab.com/elixxir/crypto/cyclic"
+	"gitlab.com/xx_network/primitives/id"
+	"testing"
+)
+
+// Test implementation of the Manager interface
+type testManager struct {
+	partnerId                *id.ID
+	grp                      *cyclic.Group
+	partnerPubKey, myPrivKey *cyclic.Int
+}
+
+// NewTestManager allows creation of a Manager interface object for testing purposes
+// Backwards compatibility must be maintained if you make changes here
+// Currently used for: Group chat testing
+func NewTestManager(partnerId *id.ID, partnerPubKey, myPrivKey *cyclic.Int, t *testing.T) Manager {
+	return &testManager{partnerId: partnerId, partnerPubKey: partnerPubKey, myPrivKey: myPrivKey}
+}
+
+func (p *testManager) GetPartnerID() *id.ID {
+	return p.partnerId
+}
+
+func (p *testManager) GetMyID() *id.ID {
+	panic("implement me")
+}
+
+func (p *testManager) GetMyOriginPrivateKey() *cyclic.Int {
+	return p.myPrivKey
+}
+
+func (p *testManager) GetPartnerOriginPublicKey() *cyclic.Int {
+	return p.partnerPubKey
+}
+
+func (p *testManager) GetSendRelationshipFingerprint() []byte {
+	panic("implement me")
+}
+
+func (p *testManager) GetReceiveRelationshipFingerprint() []byte {
+	panic("implement me")
+}
+
+func (p *testManager) GetConnectionFingerprintBytes() []byte {
+	panic("implement me")
+}
+
+func (p *testManager) GetConnectionFingerprint() string {
+	panic("implement me")
+}
+
+func (p *testManager) GetContact() contact.Contact {
+	panic("implement me")
+}
+
+func (p *testManager) PopSendCypher() (*session.Cypher, error) {
+	panic("implement me")
+}
+
+func (p *testManager) PopRekeyCypher() (*session.Cypher, error) {
+	panic("implement me")
+}
+
+func (p *testManager) NewReceiveSession(partnerPubKey *cyclic.Int, partnerSIDHPubKey *sidh.PublicKey, e2eParams session.Params, source *session.Session) (*session.Session, bool) {
+	panic("implement me")
+}
+
+func (p *testManager) NewSendSession(myDHPrivKey *cyclic.Int, mySIDHPrivateKey *sidh.PrivateKey, e2eParams session.Params, source *session.Session) *session.Session {
+	panic("implement me")
+}
+
+func (p *testManager) GetSendSession(sid session.SessionID) *session.Session {
+	panic("implement me")
+}
+
+func (p *testManager) GetReceiveSession(sid session.SessionID) *session.Session {
+	panic("implement me")
+}
+
+func (p *testManager) Confirm(sid session.SessionID) error {
+	panic("implement me")
+}
+
+func (p *testManager) TriggerNegotiations() []*session.Session {
+	panic("implement me")
+}
+
+func (p *testManager) MakeService(tag string) message.Service {
+	panic("implement me")
+}
+
+func (p *testManager) Delete() error {
+	panic("implement me")
+}

groupChat/makeGroup.go

@@ -29,7 +29,6 @@ const (
 	makeMembershipErr = "failed to assemble group chat membership: %+v"
 	newIdPreimageErr  = "failed to create group ID preimage: %+v"
 	newKeyPreimageErr = "failed to create group key preimage: %+v"
-	addGroupErr       = "failed to save new group: %+v"
 )
 
 // MaxInitMessageSize is the maximum allowable length of the initial message
@@ -81,16 +80,12 @@ func (m Manager) MakeGroup(membership []*id.ID, name, msg []byte) (gs.Group,
 	// Create new group and add to manager
 	g := gs.NewGroup(
 		name, groupID, groupKey, idPreimage, keyPreimage, msg, created, mem, dkl)
-	if err = m.gs.Add(g); err != nil {
-		return gs.Group{}, nil, NotSent, errors.Errorf(addGroupErr, err)
-	}
 
 	jww.DEBUG.Printf("Created new group %q with ID %s and %d members %s",
 		g.Name, g.ID, len(g.Members), g.Members)
 
 	// Send all group requests
 	roundIDs, status, err := m.sendRequests(g)
-
 	if err == nil {
 		err = m.JoinGroup(g)
 	}

groupChat/makeGroup_test.go

@@ -121,7 +121,7 @@ func TestManager_MakeGroup_AddGroupError(t *testing.T) {
 	prng := rand.New(rand.NewSource(42))
 	m, _ := newTestManagerWithStore(prng, gs.MaxGroupChats, 0, nil, nil, t)
 	memberIDs, _, _ := addPartners(m, t)
-	expectedErr := strings.SplitN(addGroupErr, "%", 2)[0]
+	expectedErr := strings.SplitN(joinGroupErr, "%", 2)[0]
 
 	_, _, _, err := m.MakeGroup(memberIDs, []byte{}, []byte{})
 	if err == nil || !strings.Contains(err.Error(), expectedErr) {

groupChat/manager_test.go

@@ -31,7 +31,7 @@ func Test_newManager(t *testing.T) {
 	requestFunc := func(g gs.Group) { requestChan <- g }
 	receiveChan := make(chan MessageReceive)
 	receiveFunc := func(msg MessageReceive) { receiveChan <- msg }
-	m, err := NewManager(nil, nil, user.ID, nil, nil, kv, requestFunc, receiveFunc)
+	m, err := NewManager(nil, newTestE2eManager(user.DhKey), user.ID, nil, nil, kv, requestFunc, receiveFunc)
 	if err != nil {
 		t.Errorf("newManager() returned an error: %+v", err)
 	}
@@ -84,7 +84,7 @@ func Test_newManager_LoadStorage(t *testing.T) {
 		}
 	}
 
-	m, err := NewManager(nil, nil, user.ID, nil, nil, kv, nil, nil)
+	m, err := NewManager(newTestNetworkManager(0, t), newTestE2eManager(user.DhKey), user.ID, nil, nil, kv, nil, nil)
 	if err != nil {
 		t.Errorf("newManager() returned an error: %+v", err)
 	}
@@ -118,7 +118,7 @@ func Test_newManager_LoadError(t *testing.T) {
 
 	expectedErr := strings.SplitN(newGroupStoreErr, "%", 2)[0]
 
-	_, err = NewManager(nil, nil, user.ID, nil, nil, kv, nil, nil)
+	_, err = NewManager(nil, newTestE2eManager(user.DhKey), user.ID, nil, nil, kv, nil, nil)
 	if err == nil || !strings.Contains(err.Error(), expectedErr) {
 		t.Errorf("newManager() did not return the expected error."+
 			"\nexpected: %s\nreceived: %+v", expectedErr, err)

groupChat/utils_test.go

@@ -47,15 +47,11 @@ func newTestManager(rng *rand.Rand, t *testing.T) (*Manager, gs.Group) {
 		rng:         fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG),
 		grp:         getGroup(),
 		services:    newTestNetworkManager(0, t),
-		e2e: &testE2eManager{
-			e2eMessages: []testE2eMessage{},
-			errSkip:     0,
-			sendErr:     0,
-		},
+		e2e:         newTestE2eManager(randCycInt(rng)),
 	}
 	user := group.Member{
 		ID:    m.receptionId,
-		DhKey: randCycInt(rng),
+		DhKey: m.e2e.GetHistoricalDHPubkey(),
 	}
 
 	g := newTestGroupWithUser(m.grp, user.ID, user.DhKey,
@@ -82,16 +78,11 @@ func newTestManagerWithStore(rng *rand.Rand, numGroups int, sendErr int,
 		requestFunc: requestFunc,
 		receiveFunc: receiveFunc,
 		services:    newTestNetworkManager(sendErr, t),
-		e2e: &testE2eManager{
-			e2eMessages: []testE2eMessage{},
-			errSkip:     0,
-			sendErr:     sendErr,
-		},
+		e2e:         newTestE2eManager(randCycInt(rng)),
 	}
-
 	user := group.Member{
 		ID:    m.receptionId,
-		DhKey: randCycInt(rng),
+		DhKey: m.e2e.GetHistoricalDHPubkey(),
 	}
 
 	gStore, err := gs.NewStore(versioned.NewKV(make(ekv.Memstore)), user)
@@ -111,6 +102,16 @@ func newTestManagerWithStore(rng *rand.Rand, numGroups int, sendErr int,
 	return m, g
 }
 
+func newTestE2eManager(dhPubKey *cyclic.Int) *testE2eManager {
+	return &testE2eManager{
+		e2eMessages: []testE2eMessage{},
+		errSkip:     0,
+		grp:         getGroup(),
+		dhPubKey:    dhPubKey,
+		partners:    make(map[id.ID]partner.Manager),
+	}
+}
+
 // getMembership returns a Membership with random members for testing.
 func getMembership(size int, uid *id.ID, pubKey *cyclic.Int, grp *cyclic.Group,
 	prng *rand.Rand, t *testing.T) group.Membership {
@@ -226,8 +227,11 @@ func newTestNetworkManager(sendErr int, t *testing.T) GroupCmix {
 // testE2eManager is a test implementation of NetworkManager interface.
 type testE2eManager struct {
 	e2eMessages []testE2eMessage
+	partners    map[id.ID]partner.Manager
 	errSkip     int
 	sendErr     int
+	dhPubKey    *cyclic.Int
+	grp         *cyclic.Group
 	sync.RWMutex
 }
 
@@ -237,20 +241,27 @@ type testE2eMessage struct {
 }
 
 func (tnm *testE2eManager) AddPartner(partnerID *id.ID, partnerPubKey, myPrivKey *cyclic.Int,
-	partnerSIDHPubKey *sidh.PublicKey, mySIDHPrivKey *sidh.PrivateKey, sendParams, receiveParams session.Params) (partner.Manager, error) {
-	return nil, nil
+	partnerSIDHPubKey *sidh.PublicKey, mySIDHPrivKey *sidh.PrivateKey,
+	sendParams, receiveParams session.Params) (partner.Manager, error) {
+
+	testPartner := partner.NewTestManager(partnerID, partnerPubKey, myPrivKey, &testing.T{})
+	tnm.partners[*partnerID] = testPartner
+	return testPartner, nil
 }
 
 func (tnm *testE2eManager) GetPartner(partnerID *id.ID) (partner.Manager, error) {
-	return nil, nil
+	if partner, ok := tnm.partners[*partnerID]; ok {
+		return partner, nil
+	}
+	return nil, errors.New("Unable to find partner")
 }
 
 func (tnm *testE2eManager) GetHistoricalDHPubkey() *cyclic.Int {
-	panic("implement me")
+	return tnm.dhPubKey
 }
 
 func (tnm *testE2eManager) GetHistoricalDHPrivkey() *cyclic.Int {
-	panic("implement me")
+	return tnm.dhPubKey
 }
 
 func (tnm *testE2eManager) SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte, params clientE2E.Params) ([]id.Round, e2e.MessageID, time.Time, error) {
@@ -273,11 +284,11 @@ func (tnm *testE2eManager) SendE2E(mt catalog.MessageType, recipient *id.ID, pay
 }
 
 func (*testE2eManager) RegisterListener(user *id.ID, messageType catalog.MessageType, newListener receive.Listener) receive.ListenerID {
-	panic("implement me")
+	return receive.ListenerID{}
 }
 
 func (*testE2eManager) AddService(tag string, processor message.Processor) error {
-	panic("implement me")
+	return nil
 }
 
 func (*testE2eManager) GetDefaultHistoricalDHPubkey() *cyclic.Int {
@@ -326,11 +337,11 @@ func (tnm *testNetworkManager) SendMany(messages []cmix.TargetedCmixMessage, p c
 }
 
 func (*testNetworkManager) AddService(clientID *id.ID, newService message.Service, response message.Processor) {
-	panic("implement me")
+	return
 }
 
 func (*testNetworkManager) DeleteService(clientID *id.ID, toDelete message.Service, processor message.Processor) {
-	panic("implement me")
+	return
 }
 
 type dummyEventMgr struct{}