Merge branch 'restructure' into 'api2.0'

# Conflicts:
#   e2e/parse/firstMessagePart_test.go
#   e2e/parse/messagePart_test.go
#   e2e/parse/partition_test.go
#   e2e/sendUnsafe_test.go

e2e/parse/firstMessagePart.go

@@ -9,6 +9,7 @@ package parse
 
 import (
 	"encoding/binary"
+	"fmt"
 	"time"
 
 	jww "github.com/spf13/jwalterweatherman"
@@ -43,6 +44,9 @@ func newFirstMessagePart(mt catalog.MessageType, id uint32, numParts uint8,
 	// Create the message structure
 	m := firstMessagePartFromBytes(make([]byte, size))
 
+	fmt.Printf("len of contents: %d"+
+		"\nsize: %d\n"+
+		"len m.contents: %d\n", len(contents), size, len(m.Contents))
 	// Set the message type
 	binary.BigEndian.PutUint32(m.Type, uint32(mt))
 

e2e/parse/firstMessagePart_test.go

@@ -43,8 +43,7 @@ func Test_newFirstMessagePart(t *testing.T) {
 		1077,
 		2,
 		time.Unix(1609786229, 0).UTC(),
-		testStr,
-		len(testStr)+22,
+		[]byte{'t', 'e', 's', 't', 'i', 'n', 'g', 's', 't', 'r', 'i', 'n', 'g'}, len(expectedFMP.Data),
 	)
 
 	gotTime := fmp.getTimestamp()

e2e/parse/messagePart_test.go

@@ -26,8 +26,7 @@ var expectedMP = messagePart{
 
 // Tests that a new function part is successfully created.
 func Test_newMessagePart(t *testing.T) {
-	testStr := []byte{'t', 'e', 's', 't', 'i', 'n', 'g'}
-	goTmp := newMessagePart(32, 6, testStr, len(testStr)+8)
+	goTmp := newMessagePart(32, 6, []byte{'t', 'e', 's', 't', 'i', 'n', 'g'}, len(expectedMP.Data))
 	if !reflect.DeepEqual(goTmp, expectedMP) {
 		t.Errorf("MessagePart received and MessagePart expected do not match."+
 			"\nexpected: %#v\nreceived: %#v", expectedMP, goTmp)

e2e/parse/partition_test.go

@@ -69,8 +69,8 @@ func TestPartitioner_Partition(t *testing.T) {
 
 // Test that Partitioner.HandlePartition can handle a message part.
 func TestPartitioner_HandlePartition(t *testing.T) {
-	p := NewPartitioner(versioned.NewKV(ekv.MakeMemstore()), 256)
-	m := newMessagePart(1107, 1, []byte(ipsumTestStr), len(ipsumTestStr)+32)
+	p := NewPartitioner(versioned.NewKV(ekv.MakeMemstore()), len(ipsumTestStr))
+	m := newMessagePart(1107, 1, []byte(ipsumTestStr), len(ipsumTestStr)+headerLen)
 
 	_, _ = p.HandlePartition(
 		&id.DummyUser,
@@ -83,8 +83,7 @@ func TestPartitioner_HandlePartition(t *testing.T) {
 func TestPartitioner_HandleFirstPartition(t *testing.T) {
 	p := NewPartitioner(versioned.NewKV(ekv.MakeMemstore()), 256)
 	m := newFirstMessagePart(
-		catalog.XxMessage, 1107, 1, netTime.Now(), []byte(ipsumTestStr),
-		len(ipsumTestStr)+32)
+		catalog.XxMessage, 1107, 1, netTime.Now(), []byte(ipsumTestStr), len([]byte(ipsumTestStr))+firstHeaderLen)
 
 	_, _ = p.HandlePartition(
 		&id.DummyUser,

e2e/sendUnsafe_test.go

@@ -7,85 +7,102 @@
 
 package e2e
 
-//
-//func TestManager_SendUnsafe(t *testing.T) {
-//	streamGen := fastRNG.NewStreamGenerator(12, 1024, csprng.NewSystemRNG)
-//	rng := streamGen.GetStream()
-//	defer rng.Close()
-//	netHandler := newMockCmixHandler()
-//
-//	// Generate new E2E manager
-//	myKv := versioned.NewKV(ekv.MakeMemstore())
-//	myID := id.NewIdFromString("myID", id.User, t)
-//	myNet := newMockCmix(myID, netHandler, t)
-//	m1 := &manager{
-//		Switchboard: receive.New(),
-//		partitioner: parse.NewPartitioner(myKv, myNet.GetMaxMessageLength()),
-//		net:         myNet,
-//		myID:        myID,
-//		events:      mockEventsManager{},
-//		grp:         myNet.GetInstance().GetE2EGroup(),
-//		rekeyParams: rekey.GetDefaultParams(),
-//	}
-//
-//	myPrivKey := dh.GeneratePrivateKey(
-//		dh.DefaultPrivateKeyLength, m1.grp, rng)
-//	err := ratchet.New(myKv, myID, myPrivKey, m1.grp)
-//	if err != nil {
-//		t.Errorf("Failed to generate new ratchet: %+v", err)
-//	}
-//
-//	myFpGen := &fpGenerator{m1}
-//	myServices := newMockServices()
-//
-//	m1.Ratchet, err = ratchet.Load(
-//		myKv, myID, m1.grp, myFpGen, myServices, streamGen)
-//
-//	// Generate new E2E manager
-//	partnerKv := versioned.NewKV(ekv.MakeMemstore())
-//	partnerID := id.NewIdFromString("partnerID", id.User, t)
-//	partnerNet := newMockCmix(partnerID, netHandler, t)
-//	m2 := &manager{
-//		Switchboard: receive.New(),
-//		partitioner: parse.NewPartitioner(partnerKv, partnerNet.GetMaxMessageLength()),
-//		net:         partnerNet,
-//		myID:        partnerID,
-//		events:      mockEventsManager{},
-//		grp:         partnerNet.GetInstance().GetE2EGroup(),
-//		rekeyParams: rekey.GetDefaultParams(),
-//	}
-//
-//	receiveChan := make(chan receive.Message, 10)
-//	m2.Switchboard.RegisterListener(partnerID, catalog.NoType, &mockListener{receiveChan})
-//
-//	partnerPrivKey := dh.GeneratePrivateKey(
-//		dh.DefaultPrivateKeyLength, m2.grp, rng)
-//	err = ratchet.New(partnerKv, partnerID, partnerPrivKey, m2.grp)
-//	if err != nil {
-//		t.Errorf("Failed to generate new ratchet: %+v", err)
-//	}
-//
-//	partnerFpGen := &fpGenerator{m2}
-//	partnerServices := newMockServices()
-//
-//	m1.Ratchet, err = ratchet.Load(
-//		partnerKv, partnerID, m2.grp, partnerFpGen, partnerServices, streamGen)
-//
-//	// Generate partner identity and add partner
-//	partnerPubKey, partnerSidhPubKey, mySidhPrivKey, sessionParams :=
-//		genPartnerKeys(partnerPrivKey, m1.grp, rng, t)
-//	_, err = m1.Ratchet.AddPartner(partnerID, partnerPubKey, myPrivKey,
-//		partnerSidhPubKey, mySidhPrivKey, sessionParams, sessionParams)
-//	if err != nil {
-//		t.Errorf("Failed to add partner: %+v", err)
-//	}
-//
-//	payload := []byte("My Payload")
-//	p := GetDefaultParams()
-//
-//
-//	_, _, err = m1.sendUnsafe(catalog.NoType, partnerID, payload, p)
-//	if err != nil {
-//		t.Fatalf("sendUnsafe error: %v", err)
-//	}
-//}
+import (
+	"gitlab.com/elixxir/client/catalog"
+	"gitlab.com/elixxir/client/e2e/parse"
+	"gitlab.com/elixxir/client/e2e/ratchet"
+	"gitlab.com/elixxir/client/e2e/receive"
+	"gitlab.com/elixxir/client/e2e/rekey"
+	"gitlab.com/elixxir/client/storage/versioned"
+	dh "gitlab.com/elixxir/crypto/diffieHellman"
+	"gitlab.com/elixxir/crypto/fastRNG"
+	"gitlab.com/elixxir/ekv"
+	"gitlab.com/xx_network/crypto/csprng"
+	"gitlab.com/xx_network/primitives/id"
+	"testing"
+)
+
+func TestManager_SendUnsafe(t *testing.T) {
+	streamGen := fastRNG.NewStreamGenerator(12,
+		1024, csprng.NewSystemRNG)
+	rng := streamGen.GetStream()
+	defer rng.Close()
+	netHandler := newMockCmixHandler()
+
+	// Generate new E2E manager
+	myKv := versioned.NewKV(ekv.MakeMemstore())
+	myID := id.NewIdFromString("myID", id.User, t)
+	myNet := newMockCmix(myID, netHandler, t)
+	m1 := &manager{
+		Switchboard: receive.New(),
+		partitioner: parse.NewPartitioner(myKv, myNet.GetMaxMessageLength()),
+		net:         myNet,
+		myID:        myID,
+		events:      mockEventsManager{},
+		grp:         myNet.GetInstance().GetE2EGroup(),
+		rekeyParams: rekey.GetDefaultParams(),
+	}
+
+	myPrivKey := dh.GeneratePrivateKey(
+		dh.DefaultPrivateKeyLength, m1.grp, rng)
+	err := ratchet.New(myKv, myID, myPrivKey, m1.grp)
+	if err != nil {
+		t.Errorf("Failed to generate new ratchet: %+v", err)
+	}
+
+	myFpGen := &fpGenerator{m1}
+	myServices := newMockServices()
+
+	m1.Ratchet, err = ratchet.Load(
+		myKv, myID, m1.grp, myFpGen, myServices, streamGen)
+
+	// Generate new E2E manager
+	partnerKv := versioned.NewKV(ekv.MakeMemstore())
+	partnerID := id.NewIdFromString("partnerID", id.User, t)
+	partnerNet := newMockCmix(partnerID, netHandler, t)
+	m2 := &manager{
+		Switchboard: receive.New(),
+		partitioner: parse.NewPartitioner(partnerKv, partnerNet.GetMaxMessageLength()),
+		net:         partnerNet,
+		myID:        partnerID,
+		events:      mockEventsManager{},
+		grp:         partnerNet.GetInstance().GetE2EGroup(),
+		rekeyParams: rekey.GetDefaultParams(),
+	}
+
+	receiveChan := make(chan receive.Message, 10)
+	m2.Switchboard.RegisterListener(myID, catalog.NoType, &mockListener{receiveChan})
+
+	partnerPrivKey := dh.GeneratePrivateKey(
+		dh.DefaultPrivateKeyLength, m2.grp, rng)
+	err = ratchet.New(partnerKv, partnerID, partnerPrivKey, m2.grp)
+	if err != nil {
+		t.Errorf("Failed to generate new ratchet: %+v", err)
+	}
+
+	partnerFpGen := &fpGenerator{m2}
+	partnerServices := newMockServices()
+
+	m1.Ratchet, err = ratchet.Load(
+		partnerKv, partnerID, m2.grp, partnerFpGen, partnerServices, streamGen)
+
+	m1.EnableUnsafeReception()
+	m2.EnableUnsafeReception()
+
+	// Generate partner identity and add partner
+	partnerPubKey, partnerSidhPubKey, mySidhPrivKey, sessionParams :=
+		genPartnerKeys(partnerPrivKey, m1.grp, rng, t)
+	_, err = m1.Ratchet.AddPartner(partnerID, partnerPubKey, myPrivKey,
+		partnerSidhPubKey, mySidhPrivKey, sessionParams, sessionParams)
+	if err != nil {
+		t.Errorf("Failed to add partner: %+v", err)
+	}
+
+	payload := []byte("My Payload")
+	p := GetDefaultParams()
+
+	_, _, err = m1.sendUnsafe(catalog.NoType, partnerID, payload, p)
+	if err != nil {
+		t.Fatalf("sendUnsafe error: %v", err)
+	}
+}

e2e/utils_test.go

@@ -126,12 +126,14 @@ func (m *mockServices) DeleteService(
 
 type mockCmixHandler struct {
 	processorMap map[format.Fingerprint]message.Processor
+	serviceMap   map[string]message.Processor
 	sync.Mutex
 }
 
 func newMockCmixHandler() *mockCmixHandler {
 	return &mockCmixHandler{
 		processorMap: make(map[format.Fingerprint]message.Processor),
+		serviceMap:   make(map[string]message.Processor),
 	}
 }
 
@@ -172,7 +174,7 @@ func (m *mockCmix) GetMaxMessageLength() int {
 	return msg.ContentsSize()
 }
 
-func (m *mockCmix) Send(_ *id.ID, fp format.Fingerprint, _ message.Service,
+func (m *mockCmix) Send(_ *id.ID, fp format.Fingerprint, srv message.Service,
 	payload, mac []byte, _ cmix.CMIXParams) (id.Round, ephemeral.Id, error) {
 	m.handler.Lock()
 	defer m.handler.Unlock()
@@ -182,16 +184,20 @@ func (m *mockCmix) Send(_ *id.ID, fp format.Fingerprint, _ message.Service,
 	msg.SetMac(mac)
 	msg.SetKeyFP(fp)
 
-	if m.handler.processorMap[fp] == nil {
+	if m.handler.processorMap[fp] != nil {
+		m.handler.processorMap[fp].Process(
+			msg, receptionID.EphemeralIdentity{}, rounds.Round{})
+		return 0, ephemeral.Id{}, nil
+	} else if m.handler.serviceMap[srv.Tag] != nil {
+		m.handler.serviceMap[srv.Tag].Process(
+			msg, receptionID.EphemeralIdentity{}, rounds.Round{})
+		return 0, ephemeral.Id{}, nil
+	}
+
 	m.t.Errorf("No processor found for fingerprint %s", fp)
 	return 0, ephemeral.Id{},
 		errors.Errorf("No processor found for fingerprint %s", fp)
-	}
 
-	m.handler.processorMap[fp].Process(
-		msg, receptionID.EphemeralIdentity{}, rounds.Round{})
-
-	return 0, ephemeral.Id{}, nil
 }
 
 func (m *mockCmix) SendMany([]cmix.TargetedCmixMessage, cmix.CMIXParams) (id.Round, []ephemeral.Id, error) {
@@ -214,8 +220,14 @@ func (m *mockCmix) DeleteFingerprint(_ *id.ID, fp format.Fingerprint) {
 	m.handler.Unlock()
 }
 
+func (m *mockCmix) AddService(myId *id.ID, srv message.Service, proc message.Processor) {
+	m.handler.Lock()
+	m.handler.serviceMap[srv.Tag] = proc
+	m.handler.Unlock()
+
+}
+
 func (m *mockCmix) DeleteClientFingerprints(*id.ID)                          {}
-func (m *mockCmix) AddService(*id.ID, message.Service, message.Processor)    {}
 func (m *mockCmix) DeleteService(*id.ID, message.Service, message.Processor) {}
 func (m *mockCmix) DeleteClientService(*id.ID)                               {}
 func (m *mockCmix) TrackServices(message.ServicesTracker)                    {}