Fix proxy_test

Author: Manav-Aggarwal

block/manager_test.go

@@ -61,7 +61,7 @@ func getManager(t *testing.T, da da.DA, gasPrice float64, gasMultiplier float64)
 // TestInitialStateClean verifies that getInitialState initializes state correctly when no state is stored.
 func TestInitialStateClean(t *testing.T) {
 	require := require.New(t)
-	ctx := context.TODO()
+	ctx := t.Context()
 
 	// Create genesis document
 	genesisData, _, _ := types.GetGenesisWithPrivkey("TestInitialStateClean")

core/da/dummy.go

@@ -162,7 +162,7 @@ func (d *DummyDA) SubmitWithOptions(ctx context.Context, blobs []Blob, gasPrice
 	d.mu.Lock()
 	defer d.mu.Unlock()
 
-	height := uint64(len(d.blobsByHeight))
+	height := d.currentHeight
 	ids := make([]ID, 0, len(blobs))
 	var currentSize uint64
 

core/da/dummy_test.go

@@ -9,6 +9,7 @@ import (
 func TestDummyDA(t *testing.T) {
 	// Create a new DummyDA instance with a max blob size of 1024 bytes
 	dummyDA := NewDummyDA(1024, 0, 0, 10*time.Second)
+	// Height is always 0
 	ctx := context.Background()
 
 	// Test MaxBlobSize

core/da/errors.go

@@ -11,5 +11,5 @@ var (
 	ErrTxAlreadyInMempool         = errors.New("tx already in mempool")
 	ErrTxIncorrectAccountSequence = errors.New("incorrect account sequence")
 	ErrContextDeadline            = errors.New("context deadline")
-	ErrFutureHeight               = errors.New("future height")
+	ErrHeightFromFuture           = errors.New("given height is from the future")
 )

da/cmd/local-da/local.go

@@ -112,7 +112,7 @@ func (d *LocalDA) GetIDs(ctx context.Context, height uint64, _ []byte) (*coreda.
 
 	if height > d.height {
 		d.logger.Error("GetIDs: height in future", "requested", height, "current", d.height)
-		return nil, fmt.Errorf("height %d is in the future: %w", height, coreda.ErrFutureHeight)
+		return nil, fmt.Errorf("height %d is in the future: %w", height, coreda.ErrHeightFromFuture)
 	}
 
 	kvps, ok := d.data[height]

da/jsonrpc/client.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"strings"
 
 	"cosmossdk.io/log"
 	"github.com/filecoin-project/go-jsonrpc"
@@ -60,6 +61,10 @@ func (api *API) GetIDs(ctx context.Context, height uint64, _ []byte) (*da.GetIDs
 			api.Logger.Debug("RPC call indicates blobs not found", "method", "GetIDs", "height", height)
 			return nil, err // Return the specific ErrBlobNotFound
 		}
+		if strings.Contains(err.Error(), da.ErrHeightFromFuture.Error()) {
+			api.Logger.Debug("RPC call indicates height from future", "method", "GetIDs", "height", height)
+			return nil, err // Return the specific ErrHeightFromFuture
+		}
 		api.Logger.Error("RPC call failed", "method", "GetIDs", "error", err)
 		return nil, err
 	}

da/jsonrpc/proxy_test.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -36,8 +37,14 @@ var emptyOptions = []byte{}
 // TestProxy runs the go-da DA test suite against the JSONRPC service
 // NOTE: This test requires a test JSONRPC service to run on the port
 // 3450 which is chosen to be sufficiently distinct from the default port
+
+func getTestDABlockTime() time.Duration {
+	return 100 * time.Millisecond
+}
+
 func TestProxy(t *testing.T) {
-	dummy := coreda.NewDummyDA(100_000, 0, 0, 10*time.Second)
+	dummy := coreda.NewDummyDA(100_000, 0, 0, getTestDABlockTime())
+	dummy.StartHeightTicker()
 	logger := log.NewTestLogger(t)
 	server := proxy.NewServer(logger, ServerHost, ServerPort, dummy)
 	err := server.Start(context.Background())
@@ -50,25 +57,21 @@ func TestProxy(t *testing.T) {
 
 	client, err := proxy.NewClient(context.Background(), logger, ClientURL, "", "74657374")
 	require.NoError(t, err)
-	RunDATestSuite(t, &client.DA)
-}
 
-// RunDATestSuite runs all tests against given DA
-func RunDATestSuite(t *testing.T, d coreda.DA) {
 	t.Run("Basic DA test", func(t *testing.T) {
-		BasicDATest(t, d)
+		BasicDATest(t, &client.DA)
 	})
 	t.Run("Get IDs and all data", func(t *testing.T) {
-		GetIDsTest(t, d)
+		GetIDsTest(t, &client.DA)
 	})
 	t.Run("Check Errors", func(t *testing.T) {
-		CheckErrors(t, d)
+		CheckErrors(t, &client.DA)
 	})
 	t.Run("Concurrent read/write test", func(t *testing.T) {
-		ConcurrentReadWriteTest(t, d)
+		ConcurrentReadWriteTest(t, &client.DA)
 	})
 	t.Run("Given height is from the future", func(t *testing.T) {
-		HeightFromFutureTest(t, d)
+		HeightFromFutureTest(t, &client.DA)
 	})
 }
 
@@ -77,7 +80,7 @@ func BasicDATest(t *testing.T, d coreda.DA) {
 	msg1 := []byte("message 1")
 	msg2 := []byte("message 2")
 
-	ctx := context.TODO()
+	ctx := t.Context()
 	id1, err := d.Submit(ctx, []coreda.Blob{msg1}, 0, testNamespace)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id1)
@@ -86,6 +89,8 @@ func BasicDATest(t *testing.T, d coreda.DA) {
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id2)
 
+	time.Sleep(getTestDABlockTime())
+
 	id3, err := d.SubmitWithOptions(ctx, []coreda.Blob{msg1}, 0, testNamespace, []byte("random options"))
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id3)
@@ -119,7 +124,7 @@ func BasicDATest(t *testing.T, d coreda.DA) {
 
 // CheckErrors ensures that errors are handled properly by DA.
 func CheckErrors(t *testing.T, d coreda.DA) {
-	ctx := context.TODO()
+	ctx := t.Context()
 	blob, err := d.Get(ctx, []coreda.ID{[]byte("invalid blob id")}, testNamespace)
 	assert.Error(t, err)
 	assert.ErrorContains(t, err, coreda.ErrBlobNotFound.Error())
@@ -130,7 +135,7 @@ func CheckErrors(t *testing.T, d coreda.DA) {
 func GetIDsTest(t *testing.T, d coreda.DA) {
 	msgs := []coreda.Blob{[]byte("msg1"), []byte("msg2"), []byte("msg3")}
 
-	ctx := context.TODO()
+	ctx := t.Context()
 	ids, err := d.Submit(ctx, msgs, 0, testNamespace)
 	assert.NoError(t, err)
 	assert.Len(t, ids, len(msgs))
@@ -140,9 +145,12 @@ func GetIDsTest(t *testing.T, d coreda.DA) {
 	// To Keep It Simple: we assume working with DA used exclusively for this test (mock, devnet, etc)
 	// As we're the only user, we don't need to handle external data (that could be submitted in real world).
 	// There is no notion of height, so we need to scan the DA to get test data back.
-	for i := uint64(1); !found && !time.Now().After(end); i++ {
+	for i := uint64(0); !found && !time.Now().After(end); i++ {
 		ret, err := d.GetIDs(ctx, i, []byte{})
 		if err != nil {
+			if strings.Contains(err.Error(), coreda.ErrHeightFromFuture.Error()) {
+				break
+			}
 			t.Error("failed to get IDs:", err)
 		}
 		assert.NotNil(t, ret)
@@ -170,7 +178,7 @@ func GetIDsTest(t *testing.T, d coreda.DA) {
 // ConcurrentReadWriteTest tests the use of mutex lock in DummyDA by calling separate methods that use `d.data` and making sure there's no race conditions
 func ConcurrentReadWriteTest(t *testing.T, d coreda.DA) {
 	var wg sync.WaitGroup
-	ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
+	ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
 	defer cancel()
 
 	writeDone := make(chan struct{})
@@ -179,7 +187,7 @@ func ConcurrentReadWriteTest(t *testing.T, d coreda.DA) {
 	go func() {
 		defer wg.Done()
 		for i := uint64(1); i <= 50; i++ {
-			_, err := d.Submit(ctx, []coreda.Blob{[]byte(fmt.Sprintf("test-%d", i))}, 0, []byte{})
+			_, err := d.Submit(ctx, []coreda.Blob{[]byte(fmt.Sprintf("test-%d", i))}, 0, []byte("test"))
 			assert.NoError(t, err)
 		}
 		close(writeDone)
@@ -193,10 +201,7 @@ func ConcurrentReadWriteTest(t *testing.T, d coreda.DA) {
 			case <-writeDone:
 				return
 			default:
-				ret, err := d.GetIDs(ctx, 1, []byte("test"))
-				if err != nil {
-					assert.Empty(t, ret.IDs)
-				}
+				d.GetIDs(ctx, 0, []byte("test"))
 			}
 		}
 	}()
@@ -206,11 +211,11 @@ func ConcurrentReadWriteTest(t *testing.T, d coreda.DA) {
 
 // HeightFromFutureTest tests the case when the given height is from the future
 func HeightFromFutureTest(t *testing.T, d coreda.DA) {
-	ctx := context.TODO()
+	ctx := t.Context()
 	_, err := d.GetIDs(ctx, 999999999, []byte("test"))
 	assert.Error(t, err)
-	// Specifically check if the error is ErrBlobNotFound (or contains its message)
-	assert.ErrorContains(t, err, coreda.ErrBlobNotFound.Error())
+	// Specifically check if the error contains the error message ErrHeightFromFuture
+	assert.ErrorContains(t, err, coreda.ErrHeightFromFuture.Error())
 }
 
 // TestSubmitWithOptions tests the SubmitWithOptions method with various scenarios

node/full_node_integration_test.go

@@ -163,7 +163,7 @@ func (s *FullNodeTestSuite) TestBlockProduction() {
 	// Verify chain state
 	state, err := s.node.Store.GetState(s.ctx)
 	s.NoError(err)
-	s.GreaterOrEqual(height, state.LastBlockHeight)
+	s.GreaterOrEqual(state.LastBlockHeight, height)
 
 	// Verify at least one block contains the test transaction
 	s.True(foundTx, "Expected at least one block to contain the test transaction")

node/helpers_test.go

@@ -43,7 +43,6 @@ func createTestComponents(t *testing.T, config rollkitconfig.Config) (coreexecut
 	executor := coreexecutor.NewDummyExecutor()
 	sequencer := coresequencer.NewDummySequencer()
 	dummyDA := coreda.NewDummyDA(100_000, 0, 0, config.DA.BlockTime.Duration)
-	dummyDA.StartHeightTicker()
 
 	// Create genesis and keys for P2P client
 	_, genesisValidatorKey, _ := types.GetGenesisWithPrivkey("test-chain")