Fix getRoundResults tests

network/results_test.go

@@ -7,7 +7,6 @@
 package network
 
 import (
-	"gitlab.com/elixxir/client/api"
 	pb "gitlab.com/elixxir/comms/mixmessages"
 	ds "gitlab.com/elixxir/comms/network/dataStructures"
 	"gitlab.com/elixxir/primitives/states"
@@ -26,34 +25,40 @@ func TestClient_GetRoundResults(t *testing.T) {
 		roundList = append(roundList, id.Round(i))
 	}
 
-	// Pre-populate the results channel with successful rounds
+	testTopology := [][]byte{id.NewIdFromUInt(1, id.Node, t).Bytes(),
+		id.NewIdFromUInt(2, id.Node, t).Bytes(),
+		id.NewIdFromUInt(3, id.Node, t).Bytes(),
+		id.NewIdFromUInt(4, id.Node, t).Bytes(),
+	}
+
+	// Pre-populate the results channel with successful round
 	sendResults := make(chan ds.EventReturn, len(roundList))
 	for i := 0; i < numRounds; i++ {
 		sendResults <- ds.EventReturn{
 			RoundInfo: &pb.RoundInfo{
-				ID:    uint64(i),
-				State: uint32(states.COMPLETED),
+				ID:       uint64(i),
+				State:    uint32(states.COMPLETED),
+				Topology: testTopology,
 			},
 			TimedOut: false,
 		}
 	}
 
-	// Create a new copy of the test client for this test
-	client, err := api.newTestingClient(t)
+	m, err := newTestManager(t)
 	if err != nil {
-		t.Fatalf("Failed in setup: %+v", err)
+		t.Fatalf("Failed in setup: %v", err)
 	}
 
 	// Construct the round call back function signature
 	var successfulRounds, timeout bool
-	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
+	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
 		successfulRounds = allRoundsSucceeded
 		timeout = timedOut
 	}
 
 	// Call the round results
-	err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
-		receivedRCB, sendResults, api.NewNoHistoricalRoundsComm())
+	err = m.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
+		receivedRCB, sendResults)
 	if err != nil {
 		t.Errorf("Error in happy path: %v", err)
 	}
@@ -82,14 +87,21 @@ func TestClient_GetRoundResults_FailedRounds(t *testing.T) {
 		roundList = append(roundList, id.Round(i))
 	}
 
+	testTopology := [][]byte{id.NewIdFromUInt(1, id.Node, t).Bytes(),
+		id.NewIdFromUInt(2, id.Node, t).Bytes(),
+		id.NewIdFromUInt(3, id.Node, t).Bytes(),
+		id.NewIdFromUInt(4, id.Node, t).Bytes(),
+	}
+
 	// Pre-populate the results channel with mostly successful rounds
 	sendResults := make(chan ds.EventReturn, len(roundList))
 	for i := 0; i < numRounds; i++ {
 		// Last two rounds will have a failure and a timeout respectively
 		result := ds.EventReturn{
 			RoundInfo: &pb.RoundInfo{
-				ID:    uint64(i),
-				State: uint32(states.COMPLETED),
+				ID:       uint64(i),
+				State:    uint32(states.COMPLETED),
+				Topology: testTopology,
 			},
 			TimedOut: false,
 		}
@@ -101,22 +113,22 @@ func TestClient_GetRoundResults_FailedRounds(t *testing.T) {
 
 	}
 
-	// Create a new copy of the test client for this test
-	client, err := api.newTestingClient(t)
+	// Create a new copy of the test manager for this test
+	m, err := newTestManager(t)
 	if err != nil {
 		t.Fatalf("Failed in setup: %v", err)
 	}
 
 	// Construct the round call back function signature
 	var successfulRounds, timeout bool
-	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
+	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
 		successfulRounds = allRoundsSucceeded
 		timeout = timedOut
 	}
 
 	// Call the round results
-	err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
-		receivedRCB, sendResults, api.NewNoHistoricalRoundsComm())
+	err = m.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
+		receivedRCB, sendResults)
 	if err != nil {
 		t.Errorf("Error in happy path: %v", err)
 	}
@@ -141,54 +153,47 @@ func TestClient_GetRoundResults_HistoricalRounds(t *testing.T) {
 		roundList = append(roundList, id.Round(i))
 	}
 
+	testTopology := [][]byte{id.NewIdFromUInt(1, id.Node, t).Bytes(),
+		id.NewIdFromUInt(2, id.Node, t).Bytes(),
+		id.NewIdFromUInt(3, id.Node, t).Bytes(),
+		id.NewIdFromUInt(4, id.Node, t).Bytes(),
+	}
+
 	// Pre-populate the results channel with successful rounds
 	sendResults := make(chan ds.EventReturn, len(roundList)-2)
 	for i := 0; i < numRounds; i++ {
 		// Skip sending rounds intended for historical rounds comm
-		if i == api.failedHistoricalRoundID ||
-			i == api.completedHistoricalRoundID {
+		if i == failedHistoricalRoundID ||
+			i == completedHistoricalRoundID {
 			continue
 		}
 
 		sendResults <- ds.EventReturn{
 			RoundInfo: &pb.RoundInfo{
-				ID:    uint64(i),
-				State: uint32(states.COMPLETED),
+				ID:       uint64(i),
+				State:    uint32(states.COMPLETED),
+				Topology: testTopology,
 			},
 			TimedOut: false,
 		}
 	}
 
-	// Create a new copy of the test client for this test
-	client, err := api.newTestingClient(t)
+	// Create a new copy of the test manager for this test
+	m, err := newTestManager(t)
 	if err != nil {
 		t.Fatalf("Failed in setup: %v", err)
 	}
 
-	// Overpopulate the round buffer, ensuring a circle back of the ring buffer
-	for i := 1; i <= ds.RoundInfoBufLen+api.completedHistoricalRoundID+1; i++ {
-		ri := &pb.RoundInfo{ID: uint64(i)}
-		if err = api.signRoundInfo(ri); err != nil {
-			t.Errorf("Failed to sign round in set up: %v", err)
-		}
-
-		_, err = client.network.GetInstance().RoundUpdate(ri)
-		if err != nil {
-			t.Errorf("Failed to upsert round in set up: %v", err)
-		}
-
-	}
-
 	// Construct the round call back function signature
 	var successfulRounds, timeout bool
-	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
+	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
 		successfulRounds = allRoundsSucceeded
 		timeout = timedOut
 	}
 
 	// Call the round results
-	err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
-		receivedRCB, sendResults, api.NewHistoricalRoundsComm())
+	err = m.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
+		receivedRCB, sendResults)
 	if err != nil {
 		t.Errorf("Error in happy path: %v", err)
 	}
@@ -217,22 +222,22 @@ func TestClient_GetRoundResults_Timeout(t *testing.T) {
 	var sendResults chan ds.EventReturn
 	sendResults = nil
 
-	// Create a new copy of the test client for this test
-	client, err := api.newTestingClient(t)
+	// Create a new copy of the test manager for this test
+	m, err := newTestManager(t)
 	if err != nil {
 		t.Fatalf("Failed in setup: %v", err)
 	}
 
 	// Construct the round call back function signature
 	var successfulRounds, timeout bool
-	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
+	receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
 		successfulRounds = allRoundsSucceeded
 		timeout = timedOut
 	}
 
 	// Call the round results
-	err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
-		receivedRCB, sendResults, api.NewNoHistoricalRoundsComm())
+	err = m.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
+		receivedRCB, sendResults)
 	if err != nil {
 		t.Errorf("Error in happy path: %v", err)
 	}

network/utils_test.go

+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC                                          //
+//                                                                           //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file                                                              //
+///////////////////////////////////////////////////////////////////////////////
+package network
+
+import (
+	"gitlab.com/elixxir/client/storage"
+	"gitlab.com/elixxir/comms/client"
+	commsNetwork "gitlab.com/elixxir/comms/network"
+	"gitlab.com/elixxir/crypto/fastRNG"
+	"gitlab.com/xx_network/comms/connect"
+	"gitlab.com/xx_network/crypto/csprng"
+	"gitlab.com/xx_network/primitives/id"
+	"gitlab.com/xx_network/primitives/ndf"
+	"testing"
+)
+
+func newTestManager(t *testing.T) (*manager, error) {
+
+	commsManager := connect.NewManagerTesting(t)
+	instanceComms := &connect.ProtoComms{
+		Manager: commsManager,
+	}
+
+	thisInstance, err := commsNetwork.NewInstanceTesting(instanceComms, getNDF(), getNDF(), nil, nil, t)
+	if err != nil {
+		return nil, err
+	}
+
+	comms, err := client.NewClientComms(id.NewIdFromUInt(100, id.User, t), nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	m := &manager{
+		session:  storage.InitTestingSession(t),
+		rng:      fastRNG.NewStreamGenerator(1000, 10, csprng.NewSystemRNG),
+		comms:    comms,
+		instance: thisInstance,
+		param:    GetDefaultParams(),
+		// todo: for other tests, these may need to be initialized with test values.
+		//  That explodes this setup function massively, may need a different setup
+		//  function for each embedded interface?
+		Sender:        nil,
+		Handler:       nil,
+		Registrar:     nil,
+		Retriever:     nil,
+		Pickup:        nil,
+		Space:         nil,
+		Tracker:       nil,
+		Monitor:       nil,
+		crit:          nil,
+		earliestRound: nil,
+		tracker:       nil,
+		latencySum:    0,
+		numLatencies:  0,
+		verboseRounds: nil,
+		events:        nil,
+		maxMsgLen:     0,
+	}
+
+	return m, nil
+}
+
+// Constructs a mock ndf
+func getNDF() *ndf.NetworkDefinition {
+	return &ndf.NetworkDefinition{
+		E2E: ndf.Group{
+			Prime: "E2EE983D031DC1DB6F1A7A67DF0E9A8E5561DB8E8D49413394C049B" +
+				"7A8ACCEDC298708F121951D9CF920EC5D146727AA4AE535B0922C688B55B3DD2AE" +
+				"DF6C01C94764DAB937935AA83BE36E67760713AB44A6337C20E7861575E745D31F" +
+				"8B9E9AD8412118C62A3E2E29DF46B0864D0C951C394A5CBBDC6ADC718DD2A3E041" +
+				"023DBB5AB23EBB4742DE9C1687B5B34FA48C3521632C4A530E8FFB1BC51DADDF45" +
+				"3B0B2717C2BC6669ED76B4BDD5C9FF558E88F26E5785302BEDBCA23EAC5ACE9209" +
+				"6EE8A60642FB61E8F3D24990B8CB12EE448EEF78E184C7242DD161C7738F32BF29" +
+				"A841698978825B4111B4BC3E1E198455095958333D776D8B2BEEED3A1A1A221A6E" +
+				"37E664A64B83981C46FFDDC1A45E3D5211AAF8BFBC072768C4F50D7D7803D2D4F2" +
+				"78DE8014A47323631D7E064DE81C0C6BFA43EF0E6998860F1390B5D3FEACAF1696" +
+				"015CB79C3F9C2D93D961120CD0E5F12CBB687EAB045241F96789C38E89D796138E" +
+				"6319BE62E35D87B1048CA28BE389B575E994DCA755471584A09EC723742DC35873" +
+				"847AEF49F66E43873",
+			Generator: "2",
+		},
+		CMIX: ndf.Group{
+			Prime: "9DB6FB5951B66BB6FE1E140F1D2CE5502374161FD6538DF1648218642F0B5C48" +
+				"C8F7A41AADFA187324B87674FA1822B00F1ECF8136943D7C55757264E5A1A44F" +
+				"FE012E9936E00C1D3E9310B01C7D179805D3058B2A9F4BB6F9716BFE6117C6B5" +
+				"B3CC4D9BE341104AD4A80AD6C94E005F4B993E14F091EB51743BF33050C38DE2" +
+				"35567E1B34C3D6A5C0CEAA1A0F368213C3D19843D0B4B09DCB9FC72D39C8DE41" +
+				"F1BF14D4BB4563CA28371621CAD3324B6A2D392145BEBFAC748805236F5CA2FE" +
+				"92B871CD8F9C36D3292B5509CA8CAA77A2ADFC7BFD77DDA6F71125A7456FEA15" +
+				"3E433256A2261C6A06ED3693797E7995FAD5AABBCFBE3EDA2741E375404AE25B",
+			Generator: "5C7FF6B06F8F143FE8288433493E4769C4D988ACE5BE25A0E24809670716C613" +
+				"D7B0CEE6932F8FAA7C44D2CB24523DA53FBE4F6EC3595892D1AA58C4328A06C4" +
+				"6A15662E7EAA703A1DECF8BBB2D05DBE2EB956C142A338661D10461C0D135472" +
+				"085057F3494309FFA73C611F78B32ADBB5740C361C9F35BE90997DB2014E2EF5" +
+				"AA61782F52ABEB8BD6432C4DD097BC5423B285DAFB60DC364E8161F4A2A35ACA" +
+				"3A10B1C4D203CC76A470A33AFDCBDD92959859ABD8B56E1725252D78EAC66E71" +
+				"BA9AE3F1DD2487199874393CD4D832186800654760E1E34C09E4D155179F9EC0" +
+				"DC4473F996BDCE6EED1CABED8B6F116F7AD9CF505DF0F998E34AB27514B0FFE7",
+		},
+		Registration: ndf.Registration{
+			EllipticPubKey: "/WRtT+mDZGC3FXQbvuQgfqOonAjJ47IKE0zhaGTQQ70=",
+		},
+	}
+}
+
+// Round IDs to return on mock historicalRounds comm
+const failedHistoricalRoundID = 7
+const completedHistoricalRoundID = 8