From 4620f644cc68b3c56f3e8b179a97edf4b54d9553 Mon Sep 17 00:00:00 2001
From: benjamin <ben@elixxir.io>
Date: Sun, 23 Oct 2022 16:29:05 -0700
Subject: [PATCH] fixed tests

---
 network/dataStructures/roundData_test.go     | 26 ++++++++------
 network/dataStructures/roundEvents_test.go   | 20 ++++++-----
 network/dataStructures/roundUpdates_test.go  | 21 ++++++-----
 network/dataStructures/round_test.go         |  7 ++--
 network/dataStructures/waitingRounds.go      |  5 +--
 network/dataStructures/waitingRounds_test.go | 37 ++++++++++++--------
 network/instance_test.go                     | 34 +++++++++---------
 7 files changed, 88 insertions(+), 62 deletions(-)

diff --git a/network/dataStructures/roundData_test.go b/network/dataStructures/roundData_test.go
index 41de4234..c3eefc93 100644
--- a/network/dataStructures/roundData_test.go
+++ b/network/dataStructures/roundData_test.go
@@ -10,6 +10,7 @@ package dataStructures
 import (
 	"gitlab.com/elixxir/comms/mixmessages"
 	"gitlab.com/elixxir/comms/testutils"
+	"gitlab.com/elixxir/primitives/states"
 	"reflect"
 	"testing"
 )
@@ -19,8 +20,9 @@ func TestData_UpsertRound(t *testing.T) {
 
 	// Construct a mock round object
 	ri := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: 0,
+		ID:         0,
+		UpdateID:   0,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
@@ -40,8 +42,9 @@ func TestData_GetRound(t *testing.T) {
 
 	// Construct a mock round object
 	ri := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: 0,
+		ID:         0,
+		UpdateID:   0,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	testutils.SignRoundInfoRsa(ri, t)
 
@@ -64,8 +67,9 @@ func TestData_GetWrappedRound(t *testing.T) {
 
 	// Construct a mock round object
 	ri := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: 0,
+		ID:         0,
+		UpdateID:   0,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	testutils.SignRoundInfoRsa(ri, t)
 
@@ -94,8 +98,9 @@ func TestData_ComparisonFunc(t *testing.T) {
 
 	// Construct a mock round object
 	roundInfoOne := &mixmessages.RoundInfo{
-		ID:       2,
-		UpdateID: 3,
+		ID:         2,
+		UpdateID:   3,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	testutils.SignRoundInfoRsa(roundInfoOne, t)
 
@@ -109,8 +114,9 @@ func TestData_ComparisonFunc(t *testing.T) {
 
 	// Construct a mock round object
 	roundInfoTwo := &mixmessages.RoundInfo{
-		ID:       2,
-		UpdateID: 4,
+		ID:         2,
+		UpdateID:   4,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	testutils.SignRoundInfoRsa(roundInfoTwo, t)
 
diff --git a/network/dataStructures/roundEvents_test.go b/network/dataStructures/roundEvents_test.go
index 8fafbf8d..5e199feb 100644
--- a/network/dataStructures/roundEvents_test.go
+++ b/network/dataStructures/roundEvents_test.go
@@ -102,8 +102,9 @@ func TestRoundEvents_TriggerRoundEvent(t *testing.T) {
 
 	// Construct a mock round object
 	ri := &pb.RoundInfo{
-		ID:    uint64(rid),
-		State: uint32(states.PENDING),
+		ID:         uint64(rid),
+		State:      uint32(states.PENDING),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 
 	if err := testutils.SignRoundInfoRsa(ri, t); err != nil {
@@ -151,12 +152,14 @@ func TestRoundEvents_TriggerRoundEvents(t *testing.T) {
 
 	// Construct a mock round object
 	ri1 := &pb.RoundInfo{
-		ID:    uint64(rid1),
-		State: uint32(states.PENDING),
+		ID:         uint64(rid1),
+		State:      uint32(states.PENDING),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	ri2 := &pb.RoundInfo{
-		ID:    uint64(rid2),
-		State: uint32(states.PENDING),
+		ID:         uint64(rid2),
+		State:      uint32(states.PENDING),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 
 	if err := testutils.SignRoundInfoRsa(ri1, t); err != nil {
@@ -198,8 +201,9 @@ func TestRoundEvents_AddRoundEventChan(t *testing.T) {
 
 	// Construct a mock round object
 	ri := &pb.RoundInfo{
-		ID:    uint64(rid),
-		State: uint32(states.PENDING),
+		ID:         uint64(rid),
+		State:      uint32(states.PENDING),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	if err := testutils.SignRoundInfoRsa(ri, t); err != nil {
 		t.Errorf("Failed to sign mock round info: %v", err)
diff --git a/network/dataStructures/roundUpdates_test.go b/network/dataStructures/roundUpdates_test.go
index 46fac612..026fe8a2 100644
--- a/network/dataStructures/roundUpdates_test.go
+++ b/network/dataStructures/roundUpdates_test.go
@@ -10,6 +10,7 @@ package dataStructures
 import (
 	"gitlab.com/elixxir/comms/mixmessages"
 	"gitlab.com/elixxir/comms/testutils"
+	"gitlab.com/elixxir/primitives/states"
 	"testing"
 )
 
@@ -18,8 +19,9 @@ func TestUpdates_AddRound(t *testing.T) {
 	u := NewUpdates()
 	// Construct a mock round object
 	ri := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: 0,
+		ID:         0,
+		UpdateID:   0,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
 	if err != nil {
@@ -41,8 +43,9 @@ func TestUpdates_GetUpdate(t *testing.T) {
 	updateID := 3
 	// Construct a mock round object
 	ri := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: uint64(updateID),
+		ID:         0,
+		UpdateID:   uint64(updateID),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	if err := testutils.SignRoundInfoRsa(ri, t); err != nil {
 		t.Errorf("Failed to sign mock round info: %v", err)
@@ -80,8 +83,9 @@ func TestUpdates_GetUpdates(t *testing.T) {
 	updateID := 3
 	// Construct a mock round object
 	roundInfoOne := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: uint64(updateID),
+		ID:         0,
+		UpdateID:   uint64(updateID),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 
 	// Sign the round on the keys
@@ -96,8 +100,9 @@ func TestUpdates_GetUpdates(t *testing.T) {
 
 	// Construct a second eound
 	roundInfoTwo := &mixmessages.RoundInfo{
-		ID:       0,
-		UpdateID: uint64(updateID + 1),
+		ID:         0,
+		UpdateID:   uint64(updateID + 1),
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	if err := testutils.SignRoundInfoRsa(roundInfoTwo, t); err != nil {
 		t.Errorf("Failed to sign mock round info: %v", err)
diff --git a/network/dataStructures/round_test.go b/network/dataStructures/round_test.go
index 4b9e7ce0..b254a816 100644
--- a/network/dataStructures/round_test.go
+++ b/network/dataStructures/round_test.go
@@ -11,6 +11,7 @@ import (
 	"bytes"
 	"gitlab.com/elixxir/comms/mixmessages"
 	"gitlab.com/elixxir/comms/testutils"
+	"gitlab.com/elixxir/primitives/states"
 	"testing"
 )
 
@@ -19,7 +20,7 @@ func TestNewRound(t *testing.T) {
 	pubKey, _ := testutils.LoadPublicKeyTesting(t)
 	ecKey, _ := testutils.LoadEllipticPublicKey(t)
 
-	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 
 	rnd := NewRound(ri, pubKey, ecKey.GetPublic())
 
@@ -40,7 +41,7 @@ func TestNewRound(t *testing.T) {
 // Smoke test for other constructor
 func TestNewVerifiedRound(t *testing.T) {
 	pubKey, _ := testutils.LoadPublicKeyTesting(t)
-	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 
 	rnd := NewVerifiedRound(ri, pubKey)
 
@@ -61,7 +62,7 @@ func TestNewVerifiedRound(t *testing.T) {
 // Unit test of Get()
 func TestNewRound_Get(t *testing.T) {
 	pubKey, _ := testutils.LoadPublicKeyTesting(t)
-	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 	// Mock signature of roundInfo as it will be verified in codepath
 	testutils.SignRoundInfoRsa(ri, t)
 	ecPubKey, _ := testutils.LoadEllipticPublicKey(t)
diff --git a/network/dataStructures/waitingRounds.go b/network/dataStructures/waitingRounds.go
index 927b0dbd..8708c012 100644
--- a/network/dataStructures/waitingRounds.go
+++ b/network/dataStructures/waitingRounds.go
@@ -101,14 +101,15 @@ func (wr *WaitingRounds) HasValidRounds(now time.Time) bool {
 func (wr *WaitingRounds) Insert(added, removed []*Round) {
 	wr.mux.Lock()
 	defer wr.mux.Unlock()
-
+	now := netTime.Now()
 	// Add any round which should be added
 	var addedRounds uint
 	for i := range added {
 		toAdd := added[i]
-		if toAdd.StartTime().After(netTime.Now()) {
+		if toAdd.StartTime().After(now) {
 			addedRounds++
 			wr.writeRounds.Set(toAdd.info.ID, toAdd)
+		} else {
 		}
 	}
 
diff --git a/network/dataStructures/waitingRounds_test.go b/network/dataStructures/waitingRounds_test.go
index 5ab3a5ec..1e2e3ec1 100644
--- a/network/dataStructures/waitingRounds_test.go
+++ b/network/dataStructures/waitingRounds_test.go
@@ -277,16 +277,16 @@ func TestWaitingRounds_GetSlice(t *testing.T) {
 	testSlice := testWR.GetSlice()
 
 	// Convert Round slice to round info slice
-	expectedRoundInfos := make([]*pb.RoundInfo, 0, len(expectedRounds))
-	for _, val := range expectedRounds {
-		expectedRoundInfos = append(expectedRoundInfos, val.info)
+outer:
+	for i, val := range expectedRounds {
+		for _, result := range testSlice {
+			if val.info.ID == result.ID {
+				continue outer
+			}
+		}
+		t.Errorf("element %d not present", i)
 	}
 
-	if !reflect.DeepEqual(expectedRoundInfos, testSlice) {
-		t.Errorf("GetSlice() returned slice with incorrect rounds."+
-			"\n\texepcted: %v\n\treceived: %v",
-			expectedRoundInfos, testSlice)
-	}
 }
 
 // Generates two lists of round infos. The first is the expected rounds in the
@@ -302,19 +302,26 @@ func createTestRoundInfos(num int, startTime time.Time, t *testing.T) ([]*Round,
 	}
 
 	for i := 0; i < num; i++ {
-		rounds[i] = NewRound(&pb.RoundInfo{
+		include := false
+		ri := &pb.RoundInfo{
 			ID:         uint64(i),
 			State:      uint32(rand.Int63n(int64(states.NUM_STATES) - 1)),
 			Timestamps: make([]uint64, current.NUM_STATES),
-		}, pubKey, nil)
-		rounds[i].info.Timestamps[states.QUEUED] = uint64(startTime.UnixNano())
-		startTime = startTime.Add(100 * time.Millisecond)
+		}
+		ri.Timestamps[states.QUEUED] = uint64(startTime.UnixNano())
 		if i%2 == 1 {
-			rounds[i].info.State = uint32(states.QUEUED)
+			ri.State = uint32(states.QUEUED)
+			include = true
+		} else if ri.State == uint32(states.QUEUED) {
+			ri.State = uint32(states.REALTIME)
+		}
+		rounds[i] = NewRound(ri, pubKey, nil)
+		if include {
 			expectedRounds = append(expectedRounds, rounds[i])
-		} else if rounds[i].info.State == uint32(states.QUEUED) {
-			rounds[i].info.State = uint32(states.REALTIME)
 		}
+
+		startTime = startTime.Add(100 * time.Millisecond)
+
 	}
 	perm := rand.Perm(num)
 	for i, v := range perm {
diff --git a/network/instance_test.go b/network/instance_test.go
index be18a356..12cf1454 100644
--- a/network/instance_test.go
+++ b/network/instance_test.go
@@ -155,7 +155,7 @@ func TestInstance_GetRound(t *testing.T) {
 	}
 
 	// Construct a mock round object
-	ri := &mixmessages.RoundInfo{ID: uint64(1)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 	testutils.SignRoundInfoRsa(ri, t)
 
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
@@ -178,7 +178,7 @@ func TestInstance_GetWrappedRound(t *testing.T) {
 	}
 
 	// Construct a mock round object
-	ri := &mixmessages.RoundInfo{ID: uint64(1)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 	testutils.SignRoundInfoRsa(ri, t)
 
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
@@ -207,7 +207,7 @@ func TestInstance_GetRoundUpdate(t *testing.T) {
 		roundUpdates: ds.NewUpdates(),
 	}
 
-	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 	if err := testutils.SignRoundInfoRsa(ri, t); err != nil {
 		t.Fatalf("Cannot sign round info: %v", err)
 	}
@@ -234,9 +234,9 @@ func TestInstance_GetRoundUpdates(t *testing.T) {
 		t.FailNow()
 	}
 
-	roundInfoOne := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1)}
+	roundInfoOne := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(1), Timestamps: make([]uint64, states.NUM_STATES)}
 	testutils.SignRoundInfoRsa(roundInfoOne, t)
-	roundInfoTwo := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(2)}
+	roundInfoTwo := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(2), Timestamps: make([]uint64, states.NUM_STATES)}
 	testutils.SignRoundInfoRsa(roundInfoTwo, t)
 	roundOne := ds.NewRound(roundInfoOne, pubKey, nil)
 	roundTwo := ds.NewRound(roundInfoTwo, pubKey, nil)
@@ -290,10 +290,11 @@ func setupComm(t *testing.T) (*Instance, *mixmessages.NDF) {
 
 func TestInstance_RoundUpdate(t *testing.T) {
 	msg := &mixmessages.RoundInfo{
-		ID:        2,
-		UpdateID:  4,
-		State:     6,
-		BatchSize: 8,
+		ID:         2,
+		UpdateID:   4,
+		State:      6,
+		BatchSize:  8,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	privKey, err := testutils.LoadPrivateKeyTesting(t)
 	if err != nil {
@@ -385,7 +386,7 @@ func TestInstance_GetLastRoundID(t *testing.T) {
 	}
 
 	expectedLastRound := 23
-	ri := &mixmessages.RoundInfo{ID: uint64(expectedLastRound)}
+	ri := &mixmessages.RoundInfo{ID: uint64(expectedLastRound), Timestamps: make([]uint64, states.NUM_STATES)}
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
 	if err != nil {
 		t.Errorf("Failed to load public key: %v", err)
@@ -408,7 +409,7 @@ func TestInstance_GetLastUpdateID(t *testing.T) {
 	}
 
 	expectedUpdateId := 5
-	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(expectedUpdateId)}
+	ri := &mixmessages.RoundInfo{ID: uint64(1), UpdateID: uint64(expectedUpdateId), Timestamps: make([]uint64, states.NUM_STATES)}
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
 	if err != nil {
 		t.Errorf("Failed to load public key: %v", err)
@@ -432,7 +433,7 @@ func TestInstance_GetOldestRoundID(t *testing.T) {
 	}
 
 	expectedOldRoundId := id.Round(0)
-	expectedOldRoundInfo := &mixmessages.RoundInfo{ID: uint64(expectedOldRoundId)}
+	expectedOldRoundInfo := &mixmessages.RoundInfo{ID: uint64(expectedOldRoundId), Timestamps: make([]uint64, states.NUM_STATES)}
 	pubKey, err := testutils.LoadPublicKeyTesting(t)
 	if err != nil {
 		t.Errorf("Failed to load public key: %v", err)
@@ -440,7 +441,7 @@ func TestInstance_GetOldestRoundID(t *testing.T) {
 	}
 	expectedOldRound := ds.NewRound(expectedOldRoundInfo, pubKey, nil)
 
-	mockRoundInfo := &mixmessages.RoundInfo{ID: uint64(2)}
+	mockRoundInfo := &mixmessages.RoundInfo{ID: uint64(2), Timestamps: make([]uint64, states.NUM_STATES)}
 	mockRound := ds.NewRound(mockRoundInfo, pubKey, nil)
 
 	_ = i.roundData.UpsertRound(expectedOldRound)
@@ -468,7 +469,7 @@ func TestInstance_GetOldestRoundID_ManyRounds(t *testing.T) {
 
 	// Ensure a circle back in the round buffer
 	for i := 1; i <= ds.RoundInfoBufLen; i++ {
-		ri := &mixmessages.RoundInfo{ID: uint64(i)}
+		ri := &mixmessages.RoundInfo{ID: uint64(i), Timestamps: make([]uint64, states.NUM_STATES)}
 		rnd := ds.NewRound(ri, pubKey, nil)
 		_ = testInstance.roundData.UpsertRound(rnd)
 
@@ -1136,8 +1137,9 @@ func TestInstance_RoundUpdateAddsToERS(t *testing.T) {
 
 	// Build a basic RoundInfo object and sign it
 	r := &mixmessages.RoundInfo{
-		ID:       2,
-		UpdateID: 4,
+		ID:         2,
+		UpdateID:   4,
+		Timestamps: make([]uint64, states.NUM_STATES),
 	}
 	err = signature.SignRsa(r, privKey)
 	if err != nil {
-- 
GitLab