diff --git a/groupChat/e2eManager_test.go b/groupChat/e2eManager_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..cc66b2b7dfd6e0c6b4d489fd4a710974250ddd57
--- /dev/null
+++ b/groupChat/e2eManager_test.go
@@ -0,0 +1,191 @@
+package groupChat
+
+import (
+ "github.com/cloudflare/circl/dh/sidh"
+ "github.com/pkg/errors"
+ "gitlab.com/elixxir/client/catalog"
+ "gitlab.com/elixxir/client/cmix/message"
+ clientE2E "gitlab.com/elixxir/client/e2e"
+ "gitlab.com/elixxir/client/e2e/ratchet/partner"
+ sessionImport "gitlab.com/elixxir/client/e2e/ratchet/partner/session"
+ "gitlab.com/elixxir/client/e2e/receive"
+ "gitlab.com/elixxir/client/stoppable"
+ "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/e2e"
+ "gitlab.com/xx_network/primitives/id"
+ "sync"
+ "testing"
+ "time"
+)
+
+// 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
+}
+
+type testE2eMessage struct {
+ Recipient *id.ID
+ Payload []byte
+}
+
+func (tnm *testE2eManager) AddPartner(partnerID *id.ID, partnerPubKey,
+ myPrivKey *cyclic.Int, _ *sidh.PublicKey, _ *sidh.PrivateKey,
+ _, _ sessionImport.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) {
+ if p, ok := tnm.partners[*partnerID]; ok {
+ return p, nil
+ }
+ return nil, errors.New("Unable to find partner")
+}
+
+func (tnm *testE2eManager) GetHistoricalDHPubkey() *cyclic.Int {
+ return tnm.dhPubKey
+}
+
+func (tnm *testE2eManager) GetHistoricalDHPrivkey() *cyclic.Int {
+ return tnm.dhPubKey
+}
+
+func (tnm *testE2eManager) GetE2eMsg(i int) testE2eMessage {
+ tnm.RLock()
+ defer tnm.RUnlock()
+ return tnm.e2eMessages[i]
+}
+
+func (tnm *testE2eManager) SendE2E(_ catalog.MessageType, recipient *id.ID,
+ payload []byte, _ clientE2E.Params) ([]id.Round, e2e.MessageID, time.Time,
+ error) {
+ tnm.Lock()
+ defer tnm.Unlock()
+
+ tnm.errSkip++
+ if tnm.sendErr == 1 {
+ return nil, e2e.MessageID{}, time.Time{}, errors.New("SendE2E error")
+ } else if tnm.sendErr == 2 && tnm.errSkip%2 == 0 {
+ return nil, e2e.MessageID{}, time.Time{}, errors.New("SendE2E error")
+ }
+
+ tnm.e2eMessages = append(tnm.e2eMessages, testE2eMessage{
+ Recipient: recipient,
+ Payload: payload,
+ })
+
+ return []id.Round{0, 1, 2, 3}, e2e.MessageID{}, time.Time{}, nil
+}
+
+func (*testE2eManager) RegisterListener(*id.ID, catalog.MessageType, receive.Listener) receive.ListenerID {
+ return receive.ListenerID{}
+}
+
+func (*testE2eManager) AddService(string, message.Processor) error {
+ return nil
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Unused & unimplemented methods of the test object ////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+
+func (*testE2eManager) GetDefaultHistoricalDHPubkey() *cyclic.Int {
+ panic("implement me")
+}
+
+func (*testE2eManager) GetDefaultHistoricalDHPrivkey() *cyclic.Int {
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) StartProcesses() (stoppable.Stoppable, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) RegisterFunc(name string, senderID *id.ID, messageType catalog.MessageType, newListener receive.ListenerFunc) receive.ListenerID {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) RegisterChannel(name string, senderID *id.ID, messageType catalog.MessageType, newListener chan receive.Message) receive.ListenerID {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) Unregister(listenerID receive.ListenerID) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) UnregisterUserListeners(userID *id.ID) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) DeletePartner(partnerId *id.ID) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) GetAllPartnerIDs() []*id.ID {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) HasAuthenticatedChannel(partner *id.ID) bool {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) RemoveService(tag string) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) SendUnsafe(mt catalog.MessageType, recipient *id.ID, payload []byte, params clientE2E.Params) ([]id.Round, time.Time, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) EnableUnsafeReception() {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) GetGroup() *cyclic.Group {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) GetReceptionID() *id.ID {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) FirstPartitionSize() uint {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) SecondPartitionSize() uint {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) PartitionSize(payloadIndex uint) uint {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testE2eManager) PayloadSize() uint {
+ //TODO implement me
+ panic("implement me")
+}
diff --git a/groupChat/interface.go b/groupChat/interface.go
index 68c9d209ece228c7e979cc15397e86a9a2818d1e..967f98ebe6eccda4ada8ee291b41691f239b6d66 100644
--- a/groupChat/interface.go
+++ b/groupChat/interface.go
@@ -29,7 +29,7 @@ import (
sessionImport "gitlab.com/elixxir/client/e2e/ratchet/partner/session"
"gitlab.com/elixxir/client/e2e/receive"
gs "gitlab.com/elixxir/client/groupChat/groupStore"
- "gitlab.com/elixxir/client/storage/versioned"
+ "gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/xxdk"
"gitlab.com/elixxir/crypto/cyclic"
crypto "gitlab.com/elixxir/crypto/e2e"
@@ -100,6 +100,16 @@ type ReceiveCallback func(msg MessageReceive)
// Sub-interfaces from other packages //////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
+// messenger is a sub-interface mocking the xxdk.E2e object.
+// This contains methods specific for this package.
+type messenger interface {
+ GetCmix() cmix.Client
+ GetE2E() e2e.Handler
+ GetReceptionIdentity() xxdk.ReceptionIdentity
+ GetRng() *fastRNG.StreamGenerator
+ GetStorage() storage.Session
+}
+
// groupCmix is a subset of the cmix.Client interface containing only the
// methods needed by GroupChat
type groupCmix interface {
@@ -127,20 +137,3 @@ type e2eHandler interface {
GetHistoricalDHPubkey() *cyclic.Int
GetHistoricalDHPrivkey() *cyclic.Int
}
-
-// messenger is a sub-interface mocking the xxdk.E2e object.
-// This contains methods specific for this package.
-type messenger interface {
- GetCmix() groupCmix
- GetE2E() e2eHandler
- GetReceptionIdentity() xxdk.ReceptionIdentity
- GetRng() *fastRNG.StreamGenerator
- GetStorage() session
-}
-
-// session is a sub-interface of the storage.Session interface.
-// This contains the methods specific for this package.
-type session interface {
- GetE2EGroup() *cyclic.Group
- GetKV() *versioned.KV
-}
diff --git a/groupChat/messenger_test.go b/groupChat/messenger_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7cc66585b05a8262a0454ef59e27439dbef5b6df
--- /dev/null
+++ b/groupChat/messenger_test.go
@@ -0,0 +1,95 @@
+package groupChat
+
+import (
+ "gitlab.com/elixxir/client/cmix"
+ clientE2E "gitlab.com/elixxir/client/e2e"
+ "gitlab.com/elixxir/client/e2e/ratchet/partner"
+ "gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/storage/versioned"
+ "gitlab.com/elixxir/client/xxdk"
+ "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/fastRNG"
+ "gitlab.com/xx_network/crypto/csprng"
+ "gitlab.com/xx_network/primitives/id"
+ "math/rand"
+ "testing"
+)
+
+// mockMessenger implementation for messenger interface
+type mockMessenger struct {
+ receptionId *id.ID
+ net cmix.Client
+ e2e clientE2E.Handler
+ e2eGroup *cyclic.Group
+ rng *fastRNG.StreamGenerator
+ storage storage.Session
+}
+
+func newMockMessenger(t testing.TB, kv *versioned.KV) messenger {
+ receptionId := id.NewIdFromString("test", id.User, t)
+ mockCmix := newTestNetworkManager(0)
+ prng := rand.New(rand.NewSource(42))
+ e2eHandler := newTestE2eManager(randCycInt(prng), t)
+ grp := getGroup()
+ rng := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
+ mockSession := newMockSesion(kv)
+
+ return mockMessenger{
+ receptionId: receptionId,
+ net: mockCmix,
+ e2e: e2eHandler,
+ e2eGroup: grp,
+ rng: rng,
+ storage: mockSession,
+ }
+}
+
+func newMockMessengerWithStore(t testing.TB, sendErr int) messenger {
+ receptionId := id.NewIdFromString("test", id.User, t)
+ mockCmix := newTestNetworkManager(sendErr)
+ prng := rand.New(rand.NewSource(42))
+ grp := getGroup()
+ rng := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
+ mockSession := newMockSesion(nil)
+
+ return mockMessenger{
+ receptionId: receptionId,
+ net: mockCmix,
+ e2e: &testE2eManager{
+ e2eMessages: []testE2eMessage{},
+ sendErr: sendErr,
+ grp: getGroup(),
+ dhPubKey: randCycInt(prng),
+ partners: make(map[id.ID]partner.Manager),
+ },
+ e2eGroup: grp,
+ rng: rng,
+ storage: mockSession,
+ }
+}
+
+func (m mockMessenger) GetCmix() cmix.Client {
+ return m.net
+}
+
+func (m mockMessenger) GetE2E() clientE2E.Handler {
+ return m.e2e
+}
+
+func (m mockMessenger) GetReceptionIdentity() xxdk.ReceptionIdentity {
+ keyData, _ := m.e2e.GetHistoricalDHPrivkey().MarshalJSON()
+ groupData, _ := getGroup().MarshalJSON()
+ return xxdk.ReceptionIdentity{
+ ID: m.receptionId,
+ DHKeyPrivate: keyData,
+ E2eGrp: groupData,
+ }
+}
+
+func (m mockMessenger) GetRng() *fastRNG.StreamGenerator {
+ return m.rng
+}
+
+func (m mockMessenger) GetStorage() storage.Session {
+ return m.storage
+}
diff --git a/groupChat/networkManager_test.go b/groupChat/networkManager_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a6df5a6427d976a21a652d89db81e8941348f34e
--- /dev/null
+++ b/groupChat/networkManager_test.go
@@ -0,0 +1,216 @@
+package groupChat
+
+import (
+ "github.com/pkg/errors"
+ "gitlab.com/elixxir/client/cmix"
+ "gitlab.com/elixxir/client/cmix/gateway"
+ "gitlab.com/elixxir/client/cmix/identity"
+ "gitlab.com/elixxir/client/cmix/message"
+ "gitlab.com/elixxir/client/cmix/rounds"
+ "gitlab.com/elixxir/client/stoppable"
+ "gitlab.com/elixxir/comms/network"
+ "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/primitives/format"
+ "gitlab.com/xx_network/comms/connect"
+ "gitlab.com/xx_network/primitives/id"
+ "gitlab.com/xx_network/primitives/id/ephemeral"
+ "sync"
+ "time"
+)
+
+// testNetworkManager is a test implementation of NetworkManager interface.
+type testNetworkManager struct {
+ receptionMessages [][]format.Message
+ sendMessages [][]cmix.TargetedCmixMessage
+ errSkip int
+ sendErr int
+ grp *cyclic.Group
+ sync.RWMutex
+}
+
+func newTestNetworkManager(sendErr int) cmix.Client {
+ return &testNetworkManager{
+ receptionMessages: [][]format.Message{},
+ sendMessages: [][]cmix.TargetedCmixMessage{},
+ grp: getGroup(),
+ sendErr: sendErr,
+ }
+}
+
+func (tnm *testNetworkManager) SendMany(messages []cmix.TargetedCmixMessage, _ cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
+ if tnm.sendErr == 1 {
+ return 0, nil, errors.New("SendManyCMIX error")
+ }
+
+ tnm.Lock()
+ defer tnm.Unlock()
+
+ tnm.sendMessages = append(tnm.sendMessages, messages)
+
+ var receiveMessages []format.Message
+ for _, msg := range messages {
+ receiveMsg := format.NewMessage(tnm.grp.GetP().ByteLen())
+ receiveMsg.SetMac(msg.Mac)
+ receiveMsg.SetContents(msg.Payload)
+ receiveMsg.SetKeyFP(msg.Fingerprint)
+ receiveMessages = append(receiveMessages, receiveMsg)
+ }
+ tnm.receptionMessages = append(tnm.receptionMessages, receiveMessages)
+ return 0, nil, nil
+}
+
+func (*testNetworkManager) AddService(*id.ID, message.Service, message.Processor) {}
+func (*testNetworkManager) DeleteService(*id.ID, message.Service, message.Processor) {}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Unused & unimplemented methods of the test object ////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+
+func (tnm *testNetworkManager) Follow(report cmix.ClientErrorReport) (stoppable.Stoppable, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) Send(recipient *id.ID, fingerprint format.Fingerprint, service message.Service, payload, mac []byte, cmixParams cmix.CMIXParams) (id.Round, ephemeral.Id, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) AddIdentity(id *id.ID, validUntil time.Time, persistent bool) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) RemoveIdentity(id *id.ID) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetIdentity(get *id.ID) (identity.TrackedID, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) AddFingerprint(identity *id.ID, fingerprint format.Fingerprint, mp message.Processor) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) DeleteFingerprint(identity *id.ID, fingerprint format.Fingerprint) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) DeleteClientFingerprints(identity *id.ID) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) DeleteClientService(clientID *id.ID) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) TrackServices(tracker message.ServicesTracker) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) CheckInProgressMessages() {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) IsHealthy() bool {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) WasHealthy() bool {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) AddHealthCallback(f func(bool)) uint64 {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) RemoveHealthCallback(u uint64) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) HasNode(nid *id.ID) bool {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) NumRegisteredNodes() int {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) TriggerNodeRegistration(nid *id.ID) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetRoundResults(timeout time.Duration, roundCallback cmix.RoundEventCallback, roundList ...id.Round) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) LookupHistoricalRound(rid id.Round, callback rounds.RoundResultCallback) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) SendToAny(sendFunc func(host *connect.Host) (interface{}, error), stop *stoppable.Single) (interface{}, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) SendToPreferred(targets []*id.ID, sendFunc gateway.SendToPreferredFunc, stop *stoppable.Single, timeout time.Duration) (interface{}, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) SetGatewayFilter(f gateway.Filter) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetHostParams() connect.HostParams {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetAddressSpace() uint8 {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) RegisterAddressSpaceNotification(tag string) (chan uint8, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) UnregisterAddressSpaceNotification(tag string) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetInstance() *network.Instance {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetVerboseRounds() string {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (tnm *testNetworkManager) GetMaxMessageLength() int {
+ return format.NewMessage(tnm.grp.GetP().ByteLen()).ContentsSize()
+}
diff --git a/groupChat/session_test.go b/groupChat/session_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..15877e7af4c0afcb9a7b8276810ebdd21b91eb26
--- /dev/null
+++ b/groupChat/session_test.go
@@ -0,0 +1,174 @@
+package groupChat
+
+import (
+ "gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/storage/user"
+ "gitlab.com/elixxir/client/storage/versioned"
+ "gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/ekv"
+ "gitlab.com/elixxir/primitives/version"
+ "gitlab.com/xx_network/crypto/signature/rsa"
+ "gitlab.com/xx_network/primitives/id"
+ "gitlab.com/xx_network/primitives/ndf"
+ "time"
+)
+
+// mockSession is a storage.Session implementation for testing.
+type mockSession struct {
+ kv *versioned.KV
+}
+
+func newMockSesion(kv *versioned.KV) storage.Session {
+ return mockSession{kv: kv}
+}
+
+func (m mockSession) GetE2EGroup() *cyclic.Group {
+ return getGroup()
+}
+
+func (m mockSession) GetKV() *versioned.KV {
+ if m.kv != nil {
+ return m.kv
+ }
+
+ return versioned.NewKV(ekv.MakeMemstore())
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Unused & unimplemented methods of the test object ////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+
+func (m mockSession) GetClientVersion() version.Version {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) Get(key string) (*versioned.Object, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) Set(key string, object *versioned.Object) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) Delete(key string) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetCmixGroup() *cyclic.Group {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) ForwardRegistrationStatus(regStatus storage.RegistrationStatus) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetRegistrationStatus() storage.RegistrationStatus {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) SetRegCode(regCode string) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetRegCode() (string, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) SetNDF(def *ndf.NetworkDefinition) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetNDF() *ndf.NetworkDefinition {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetTransmissionID() *id.ID {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetTransmissionSalt() []byte {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetReceptionID() *id.ID {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetReceptionSalt() []byte {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetReceptionRSA() *rsa.PrivateKey {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetTransmissionRSA() *rsa.PrivateKey {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) IsPrecanned() bool {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) SetUsername(username string) error {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetUsername() (string, error) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) PortableUserInfo() user.Info {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetTransmissionRegistrationValidationSignature() []byte {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetReceptionRegistrationValidationSignature() []byte {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) GetRegistrationTimestamp() time.Time {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) SetTransmissionRegistrationValidationSignature(b []byte) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) SetReceptionRegistrationValidationSignature(b []byte) {
+ //TODO implement me
+ panic("implement me")
+}
+
+func (m mockSession) SetRegistrationTimestamp(tsNano int64) {
+ //TODO implement me
+ panic("implement me")
+}
diff --git a/groupChat/utils_test.go b/groupChat/utils_test.go
index 04d1760e8e4023d36d1e9b28ab4fd94d48c51d25..8e833258023bd68dce01316cd58ca0f7a1e05165 100644
--- a/groupChat/utils_test.go
+++ b/groupChat/utils_test.go
@@ -9,24 +9,7 @@ package groupChat
import (
"encoding/base64"
- "gitlab.com/elixxir/client/xxdk"
- "gitlab.com/elixxir/crypto/e2e"
- "gitlab.com/elixxir/crypto/fastRNG"
- "gitlab.com/xx_network/crypto/csprng"
- "math/rand"
- "sync"
- "testing"
- "time"
-
- "github.com/cloudflare/circl/dh/sidh"
- "github.com/pkg/errors"
- "gitlab.com/elixxir/client/catalog"
- "gitlab.com/elixxir/client/cmix"
- "gitlab.com/elixxir/client/cmix/message"
- clientE2E "gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/e2e/ratchet/partner"
- sessionImport "gitlab.com/elixxir/client/e2e/ratchet/partner/session"
- "gitlab.com/elixxir/client/e2e/receive"
"gitlab.com/elixxir/client/event"
gs "gitlab.com/elixxir/client/groupChat/groupStore"
"gitlab.com/elixxir/client/storage/versioned"
@@ -34,116 +17,14 @@ import (
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/group"
"gitlab.com/elixxir/ekv"
- "gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/crypto/large"
"gitlab.com/xx_network/primitives/id"
- "gitlab.com/xx_network/primitives/id/ephemeral"
"gitlab.com/xx_network/primitives/ndf"
"gitlab.com/xx_network/primitives/netTime"
+ "math/rand"
+ "testing"
)
-/////////////////////////////////////////////////////////////////////////////////////////
-// mockMessenger implementation for messenger interface /////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////
-
-type mockMessenger struct {
- receptionId *id.ID
- net groupCmix
- e2e e2eHandler
- e2eGroup *cyclic.Group
- rng *fastRNG.StreamGenerator
- storage session
-}
-
-func newMockMessenger(t testing.TB, kv *versioned.KV) messenger {
- receptionId := id.NewIdFromString("test", id.User, t)
- mockCmix := newTestNetworkManager(0)
- prng := rand.New(rand.NewSource(42))
- e2eHandler := newTestE2eManager(randCycInt(prng), t)
- grp := getGroup()
- rng := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
- mockSession := newMockSesion(kv)
-
- return mockMessenger{
- receptionId: receptionId,
- net: mockCmix,
- e2e: e2eHandler,
- e2eGroup: grp,
- rng: rng,
- storage: mockSession,
- }
-}
-
-func newMockMessengerWithStore(t testing.TB, sendErr int) messenger {
- receptionId := id.NewIdFromString("test", id.User, t)
- mockCmix := newTestNetworkManager(sendErr)
- prng := rand.New(rand.NewSource(42))
- grp := getGroup()
- rng := fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG)
- mockSession := newMockSesion(nil)
-
- return mockMessenger{
- receptionId: receptionId,
- net: mockCmix,
- e2e: &testE2eManager{
- e2eMessages: []testE2eMessage{},
- sendErr: sendErr,
- grp: getGroup(),
- dhPubKey: randCycInt(prng),
- partners: make(map[id.ID]partner.Manager),
- },
- e2eGroup: grp,
- rng: rng,
- storage: mockSession,
- }
-}
-
-func (m mockMessenger) GetCmix() groupCmix {
- return m.net
-}
-
-func (m mockMessenger) GetE2E() e2eHandler {
- return m.e2e
-}
-
-func (m mockMessenger) GetReceptionIdentity() xxdk.ReceptionIdentity {
- keyData, _ := m.e2e.GetHistoricalDHPrivkey().MarshalJSON()
- groupData, _ := getGroup().MarshalJSON()
- return xxdk.ReceptionIdentity{
- ID: m.receptionId,
- DHKeyPrivate: keyData,
- E2eGrp: groupData,
- }
-}
-
-func (m mockMessenger) GetRng() *fastRNG.StreamGenerator {
- return m.rng
-}
-
-func (m mockMessenger) GetStorage() session {
- return m.storage
-}
-
-type mockSession struct {
- kv *versioned.KV
-}
-
-func newMockSesion(kv *versioned.KV) session {
- return mockSession{kv: kv}
-}
-
-func (m mockSession) GetE2EGroup() *cyclic.Group {
- return getGroup()
-}
-
-func (m mockSession) GetKV() *versioned.KV {
- if m.kv != nil {
- return m.kv
- }
-
- return versioned.NewKV(ekv.MakeMemstore())
-}
-
/////////////////////////////////////////////////////////////////////////////////////////
// mock manager implementation //////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
@@ -319,137 +200,6 @@ func getGroup() *cyclic.Group {
large.NewIntFromString(getNDF().E2E.Generator, 16))
}
-func newTestNetworkManager(sendErr int) groupCmix {
- return &testNetworkManager{
- receptionMessages: [][]format.Message{},
- sendMessages: [][]cmix.TargetedCmixMessage{},
- grp: getGroup(),
- sendErr: sendErr,
- }
-}
-
-// 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
-}
-
-type testE2eMessage struct {
- Recipient *id.ID
- Payload []byte
-}
-
-func (tnm *testE2eManager) AddPartner(partnerID *id.ID, partnerPubKey,
- myPrivKey *cyclic.Int, _ *sidh.PublicKey, _ *sidh.PrivateKey,
- _, _ sessionImport.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) {
- if p, ok := tnm.partners[*partnerID]; ok {
- return p, nil
- }
- return nil, errors.New("Unable to find partner")
-}
-
-func (tnm *testE2eManager) GetHistoricalDHPubkey() *cyclic.Int {
- return tnm.dhPubKey
-}
-
-func (tnm *testE2eManager) GetHistoricalDHPrivkey() *cyclic.Int {
- return tnm.dhPubKey
-}
-
-func (tnm *testE2eManager) SendE2E(_ catalog.MessageType, recipient *id.ID,
- payload []byte, _ clientE2E.Params) ([]id.Round, e2e.MessageID, time.Time,
- error) {
- tnm.Lock()
- defer tnm.Unlock()
-
- tnm.errSkip++
- if tnm.sendErr == 1 {
- return nil, e2e.MessageID{}, time.Time{}, errors.New("SendE2E error")
- } else if tnm.sendErr == 2 && tnm.errSkip%2 == 0 {
- return nil, e2e.MessageID{}, time.Time{}, errors.New("SendE2E error")
- }
-
- tnm.e2eMessages = append(tnm.e2eMessages, testE2eMessage{
- Recipient: recipient,
- Payload: payload,
- })
-
- return []id.Round{0, 1, 2, 3}, e2e.MessageID{}, time.Time{}, nil
-}
-
-func (*testE2eManager) RegisterListener(*id.ID, catalog.MessageType, receive.Listener) receive.ListenerID {
- return receive.ListenerID{}
-}
-
-func (*testE2eManager) AddService(string, message.Processor) error {
- return nil
-}
-
-func (*testE2eManager) GetDefaultHistoricalDHPubkey() *cyclic.Int {
- panic("implement me")
-}
-
-func (*testE2eManager) GetDefaultHistoricalDHPrivkey() *cyclic.Int {
- panic("implement me")
-}
-
-func (tnm *testE2eManager) GetE2eMsg(i int) testE2eMessage {
- tnm.RLock()
- defer tnm.RUnlock()
- return tnm.e2eMessages[i]
-}
-
-// testNetworkManager is a test implementation of NetworkManager interface.
-type testNetworkManager struct {
- receptionMessages [][]format.Message
- 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, _ cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
- if tnm.sendErr == 1 {
- return 0, nil, errors.New("SendManyCMIX error")
- }
-
- tnm.Lock()
- defer tnm.Unlock()
-
- tnm.sendMessages = append(tnm.sendMessages, messages)
-
- var receiveMessages []format.Message
- for _, msg := range messages {
- receiveMsg := format.NewMessage(tnm.grp.GetP().ByteLen())
- receiveMsg.SetMac(msg.Mac)
- receiveMsg.SetContents(msg.Payload)
- receiveMsg.SetKeyFP(msg.Fingerprint)
- receiveMessages = append(receiveMessages, receiveMsg)
- }
- tnm.receptionMessages = append(tnm.receptionMessages, receiveMessages)
- return 0, nil, nil
-}
-
-func (*testNetworkManager) AddService(*id.ID, message.Service, message.Processor) {}
-func (*testNetworkManager) DeleteService(*id.ID, message.Service, message.Processor) {}
-
type dummyEventMgr struct{}
func (d *dummyEventMgr) Report(int, string, string, string) {}