fixup! fix(jsonrpc): impose the same listed items limit for all requests in a batch

Author: renatomaia

internal/jsonrpc/batchcalls_test.go

@@ -16,6 +16,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/cartesi/rollups-node/internal/model"
+	"github.com/cartesi/rollups-node/internal/repository"
+	"github.com/cartesi/rollups-node/pkg/contracts/inputs"
+	"github.com/cartesi/rollups-node/pkg/contracts/outputs"
 	"github.com/cartesi/rollups-node/pkg/service"
 	"github.com/stretchr/testify/require"
 )
@@ -247,6 +251,123 @@ func TestJSONRPCBatchReplacesResponsesAtCumulativeResponseBudget(t *testing.T) {
 	}
 }
 
+func TestJSONRPCBatchSharesListItemLimitAcrossAllListOperations(t *testing.T) {
+	s := newBatchTestService()
+	repo := &listBudgetRepository{}
+	s.repository = repo
+	var err error
+	s.inputABI, err = inputs.InputsMetaData.GetAbi()
+	require.NoError(t, err)
+	s.outputABI, err = outputs.OutputsMetaData.GetAbi()
+	require.NoError(t, err)
+	expected := []struct{limit int; count int}{
+		{1000, 1000},
+		{2000, 2000},
+		{3000, 3000},
+		{LIST_ITEM_LIMIT, LIST_ITEM_LIMIT-6000},
+		{4000, 0},
+		{5000, 0},
+		{6000, 0},
+		{7000, 0},
+		{8000, 0},
+		{9000, 0},
+	}
+	requests := []map[string]any{
+		{"jsonrpc": "2.0", "method": "cartesi_listApplications", "params": map[string]any{"limit": expected[0].limit}, "id": 0},
+		{"jsonrpc": "2.0", "method": "cartesi_listEpochs", "params": listBudgetParams(expected[1].limit), "id": 1},
+		{"jsonrpc": "2.0", "method": "cartesi_listInputs", "params": listBudgetParams(expected[2].limit), "id": 2},
+		{"jsonrpc": "2.0", "method": "cartesi_listOutputs", "params": listBudgetParams(expected[3].limit), "id": 3},
+		{"jsonrpc": "2.0", "method": "cartesi_listReports", "params": listBudgetParams(expected[4].limit), "id": 4},
+		{"jsonrpc": "2.0", "method": "cartesi_listWithdrawals", "params": listBudgetParams(expected[5].limit), "id": 5},
+		{"jsonrpc": "2.0", "method": "cartesi_listTournaments", "params": listBudgetParams(expected[6].limit), "id": 6},
+		{"jsonrpc": "2.0", "method": "cartesi_listCommitments", "params": listBudgetParams(expected[7].limit), "id": 7},
+		{"jsonrpc": "2.0", "method": "cartesi_listMatches", "params": listBudgetParams(expected[8].limit), "id": 8},
+		{"jsonrpc": "2.0", "method": "cartesi_listMatchAdvances", "params": listMatchAdvancesBudgetParams(expected[9].limit), "id": 9},
+	}
+	body, err := json.Marshal(requests)
+	require.NoError(t, err)
+	rr := serveRPC(t, s, body)
+
+	require.Equal(t, http.StatusOK, rr.Code)
+	responses := decodeRPCBatch(t, rr.Body.Bytes())
+	require.Len(t, responses, len(requests))
+	for i, response := range responses {
+		require.Nil(t, response.Error, "list operation %s failed", requests[i]["method"])
+		result := response.Result.(map[string]any)
+		require.Equal(t, expected[i].count, len(result["data"].([]any)))
+		require.Equal(t, float64(LIST_ITEM_LIMIT), result["pagination"].(map[string]any)["total_count"])
+		require.Equal(t, float64(i), response.ID)
+	}
+}
+
+func listBudgetParams(limit int) map[string]any {
+	return map[string]any{"application": "app", "limit": limit}
+}
+
+func listMatchAdvancesBudgetParams(limit int) map[string]any {
+	params := listBudgetParams(limit)
+	params["epoch_index"] = "0x0"
+	params["tournament_address"] = "0x0000000000000000000000000000000000000000"
+	params["id_hash"] = "0x0000000000000000000000000000000000000000000000000000000000000000"
+	return params
+}
+
+type listBudgetRepository struct {
+	repository.Repository
+}
+
+func (r *listBudgetRepository) GetApplication(_ context.Context, _ string) (*model.Application, error) {
+	return &model.Application{}, nil
+}
+
+func (r *listBudgetRepository) ListApplications(_ context.Context, _ repository.ApplicationFilter, p repository.Pagination, _ bool) ([]*model.Application, uint64, error) {
+	return make([]*model.Application, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListEpochs(_ context.Context, _ string, _ repository.EpochFilter, p repository.Pagination, _ bool) ([]*model.Epoch, uint64, error) {
+	return make([]*model.Epoch, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListInputs(_ context.Context, _ string, _ repository.InputFilter, p repository.Pagination, _ bool) ([]*model.Input, uint64, error) {
+	inputs := make([]*model.Input, p.Limit)
+	for i := range inputs {
+		inputs[i] = &model.Input{RawData: []byte{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}}
+	}
+	return inputs, LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListOutputs(_ context.Context, _ string, _ repository.OutputFilter, p repository.Pagination, _ bool) ([]*model.Output, uint64, error) {
+	outputs := make([]*model.Output, p.Limit)
+	for i := range outputs {
+		outputs[i] = &model.Output{RawData: []byte{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}}
+	}
+	return outputs, LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListReports(_ context.Context, _ string, _ repository.ReportFilter, p repository.Pagination, _ bool) ([]*model.Report, uint64, error) {
+	return make([]*model.Report, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListWithdrawals(_ context.Context, _ string, _ repository.WithdrawalFilter, p repository.Pagination, _ bool) ([]*model.Withdrawal, uint64, error) {
+	return make([]*model.Withdrawal, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListTournaments(_ context.Context, _ string, _ repository.TournamentFilter, p repository.Pagination, _ bool) ([]*model.Tournament, uint64, error) {
+	return make([]*model.Tournament, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListCommitments(_ context.Context, _ string, _ repository.CommitmentFilter, p repository.Pagination, _ bool) ([]*model.Commitment, uint64, error) {
+	return make([]*model.Commitment, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListMatches(_ context.Context, _ string, _ repository.MatchFilter, p repository.Pagination, _ bool) ([]*model.Match, uint64, error) {
+	return make([]*model.Match, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
+func (r *listBudgetRepository) ListMatchAdvances(_ context.Context, _ string, _ uint64, _, _ string, p repository.Pagination, _ bool) ([]*model.MatchAdvanced, uint64, error) {
+	return make([]*model.MatchAdvanced, p.Limit), LIST_ITEM_LIMIT, nil
+}
+
 func TestJSONRPCBatchStopsBetweenEntriesWhenContextIsCanceled(t *testing.T) {
 	s := newBatchTestService()
 	var calls atomic.Int32