Server parameter validation (#250)

* Test for missing parameters

* Test for invalid parameters

* Test for emtpy parameters

* Rename tests

* Flip `assert.Equal` arguments (expected/actual)

* Extend invalid parameter testing

* Test for not found in DB

* Remove additional `&`

* Test for missing parameter

* Test `GetOperatorSetUpdateAggregation` not found

* Test for too large values

* Check for invalid ranges

* Add tests for large integers

* Tests for `GetCheckpointMessages`

* Return serialization errors

* Check for handler error

* Use `assert.NoError`

* Use `assert.AnError`

aggregator/database/database.go

@@ -263,6 +263,10 @@ func (d *Database) FetchCheckpointMessages(fromTimestamp uint64, toTimestamp uin
 		return nil, errors.New("timestamp does not fit in int64")
 	}
 
+	if (toTimestamp < fromTimestamp) {
+		return nil, errors.New("toTimestamp is less than fromTimestamp")
+	}
+
 	start := time.Now()
 	defer func() { d.listener.OnFetch(time.Since(start)) }()
 

aggregator/database/database_test.go

@@ -1,6 +1,7 @@
 package database_test
 
 import (
+	"math"
 	"math/big"
 	"testing"
 
@@ -313,3 +314,59 @@ func TestFetchCheckpointMessages(t *testing.T) {
 		OperatorSetUpdateMessageAggregations: []messages.MessageBlsAggregation{},
 	})
 }
+
+func TestFetchCheckpointMessages_TimestampTooLarge(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	db, err := database.NewDatabase(":memory:")
+	assert.Nil(t, err)
+
+	t.Run("fromTimestamp too large", func(t *testing.T) {
+		_, err := db.FetchCheckpointMessages(uint64(0x8000000000000000), 0)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("toTimestamp too large", func(t *testing.T) {
+		_, err := db.FetchCheckpointMessages(0, uint64(0x8000000000000000))
+		assert.NotNil(t, err)
+	})
+}
+
+func TestFetchCheckpointMessages_InvalidRange(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	db, err := database.NewDatabase(":memory:")
+	assert.Nil(t, err)
+
+	_, err = db.FetchCheckpointMessages(101, 100)
+	assert.NotNil(t, err)
+}
+
+func TestStoreStateRootUpdate_LargeMsgValues(t *testing.T) {
+	t.Skip("Currently impossible to store all uint64 values in the DB")
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	db, err := database.NewDatabase(":memory:")
+	assert.Nil(t, err)
+
+	msg := messages.StateRootUpdateMessage{
+		RollupId:            math.MaxUint32,
+		BlockHeight:         math.MaxUint64, // TODO: Cannot be stored, maximum possible value is `math.MaxInt64`
+		Timestamp:           math.MaxUint64, // TODO: Cannot be stored, maximum possible value is `math.MaxInt64`
+		NearDaTransactionId: [32]byte{0xFF},
+		NearDaCommitment:    [32]byte{0xFF},
+		StateRoot:           [32]byte{0xFF},
+	}
+	err = db.StoreStateRootUpdate(msg)
+	assert.Nil(t, err)
+
+	stored, err := db.FetchStateRootUpdate(math.MaxUint32, math.MaxUint64)
+	assert.NotNil(t, stored)
+	assert.Nil(t, err)
+
+	assert.Equal(t, &msg, stored)
+}

aggregator/rest_server.go

@@ -69,12 +69,12 @@ func (agg *Aggregator) handleGetStateRootUpdateAggregation(w http.ResponseWriter
 
 	w.WriteHeader(http.StatusOK)
 	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(aggtypes.GetStateRootUpdateAggregationResponse{
+	err = json.NewEncoder(w).Encode(aggtypes.GetStateRootUpdateAggregationResponse{
 		Message:     *message,
 		Aggregation: *aggregation,
 	})
 
-	return nil
+	return err
 }
 
 func (agg *Aggregator) handleGetOperatorSetUpdateAggregation(w http.ResponseWriter, r *http.Request) error {
@@ -101,12 +101,12 @@ func (agg *Aggregator) handleGetOperatorSetUpdateAggregation(w http.ResponseWrit
 
 	w.WriteHeader(http.StatusOK)
 	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(aggtypes.GetOperatorSetUpdateAggregationResponse{
+	err = json.NewEncoder(w).Encode(aggtypes.GetOperatorSetUpdateAggregationResponse{
 		Message:     *message,
 		Aggregation: *aggregation,
 	})
 
-	return nil
+	return err
 }
 
 func (agg *Aggregator) handleGetCheckpointMessages(w http.ResponseWriter, r *http.Request) error {
@@ -133,9 +133,9 @@ func (agg *Aggregator) handleGetCheckpointMessages(w http.ResponseWriter, r *htt
 
 	w.WriteHeader(http.StatusOK)
 	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(aggtypes.GetCheckpointMessagesResponse{
+	err = json.NewEncoder(w).Encode(aggtypes.GetCheckpointMessagesResponse{
 		CheckpointMessages: *checkpointMessages,
 	})
 
-	return nil
+	return err
 }