fix: Dummy test (#2300)

Fixes Deadlock in test

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 

Ex: Closes #<issue number>
-->


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **Refactor**
- Updated naming and visibility of certain components for improved
accessibility.
	- Adjusted constructor and method signatures for consistency.
- **Tests**
- Streamlined and updated test cases for better clarity and reliability.
- Modified test behavior to expect empty results rather than errors in
specific scenarios.
	- Removed unused test and helper functions.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: alpe

core/sequencer/dummy.go

@@ -10,22 +10,24 @@ import (
 // DummySequencer
 //---------------------
 
-// dummySequencer is a dummy implementation of the Sequencer interface for testing
-type dummySequencer struct {
+var _ Sequencer = (*DummySequencer)(nil)
+
+// DummySequencer is a dummy implementation of the Sequencer interface for testing
+type DummySequencer struct {
 	mu                  sync.RWMutex
 	batches             map[string]*Batch
 	batchSubmissionChan chan Batch
 }
 
 // NewDummySequencer creates a new dummy Sequencer instance
-func NewDummySequencer() Sequencer {
-	return &dummySequencer{
+func NewDummySequencer() *DummySequencer {
+	return &DummySequencer{
 		batches: make(map[string]*Batch),
 	}
 }
 
 // SubmitRollupBatchTxs submits a batch of transactions to the sequencer
-func (s *dummySequencer) SubmitRollupBatchTxs(ctx context.Context, req SubmitRollupBatchTxsRequest) (*SubmitRollupBatchTxsResponse, error) {
+func (s *DummySequencer) SubmitRollupBatchTxs(ctx context.Context, req SubmitRollupBatchTxsRequest) (*SubmitRollupBatchTxsResponse, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -37,7 +39,7 @@ func (s *dummySequencer) SubmitRollupBatchTxs(ctx context.Context, req SubmitRol
 }
 
 // GetNextBatch gets the next batch from the sequencer
-func (s *dummySequencer) GetNextBatch(ctx context.Context, req GetNextBatchRequest) (*GetNextBatchResponse, error) {
+func (s *DummySequencer) GetNextBatch(ctx context.Context, req GetNextBatchRequest) (*GetNextBatchResponse, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
@@ -53,12 +55,12 @@ func (s *dummySequencer) GetNextBatch(ctx context.Context, req GetNextBatchReque
 }
 
 // VerifyBatch verifies a batch of transactions received from the sequencer
-func (s *dummySequencer) VerifyBatch(ctx context.Context, req VerifyBatchRequest) (*VerifyBatchResponse, error) {
+func (s *DummySequencer) VerifyBatch(ctx context.Context, req VerifyBatchRequest) (*VerifyBatchResponse, error) {
 	return &VerifyBatchResponse{
 		Status: true,
 	}, nil
 }
 
-func (s *dummySequencer) SetBatchSubmissionChan(batchSubmissionChan chan Batch) {
+func (s *DummySequencer) SetBatchSubmissionChan(batchSubmissionChan chan Batch) {
 	s.batchSubmissionChan = batchSubmissionChan
 }

core/sequencer/dummy_test.go

@@ -1,30 +1,16 @@
 package sequencer
 
 import (
-	"context"
 	"fmt"
 	"reflect"
-	"strings"
 	"testing"
 	"time"
 )
 
-func TestNewDummySequencer(t *testing.T) {
-	seq := NewDummySequencer()
-	if seq == nil {
-		t.Fatal("NewDummySequencer should return a non-nil sequencer")
-	}
-
-	// Type assertion to ensure it's the correct type
-	_, ok := seq.(*dummySequencer)
-	if !ok {
-		t.Fatal("NewDummySequencer should return a *dummySequencer")
-	}
-}
-
 func TestDummySequencer_SubmitRollupBatchTxs(t *testing.T) {
 	seq := NewDummySequencer()
-	ctx := context.Background()
+	seq.SetBatchSubmissionChan(make(chan Batch, 1))
+	ctx := t.Context()
 
 	// Create a test batch
 	batch := &Batch{
@@ -66,21 +52,24 @@ func TestDummySequencer_SubmitRollupBatchTxs(t *testing.T) {
 
 func TestDummySequencer_GetNextBatch(t *testing.T) {
 	seq := NewDummySequencer()
-	ctx := context.Background()
+	seq.SetBatchSubmissionChan(make(chan Batch, 1))
+
+	ctx := t.Context()
 
 	t.Run("non-existent rollup ID", func(t *testing.T) {
 		// Try to get a batch for a non-existent rollup ID
 		nonExistentRollupID := []byte("non-existent-rollup")
-		_, err := seq.GetNextBatch(ctx, GetNextBatchRequest{
+		req, err := seq.GetNextBatch(ctx, GetNextBatchRequest{
 			RollupId: nonExistentRollupID,
 		})
-
-		// Should return an error
-		if err == nil {
-			t.Fatal("GetNextBatch should return an error for non-existent rollup ID")
+		if err != nil {
+			t.Fatalf("no error expected: %s", err)
+		}
+		if req == nil || req.Batch == nil {
+			t.Fatal("unexpected nil response")
 		}
-		if err.Error() == "" || !contains(err.Error(), "no batch found for rollup ID") {
-			t.Fatalf("Error message should indicate the rollup ID was not found, got: %v", err)
+		if len(req.Batch.Transactions) != 0 {
+			t.Error("batch should be empty")
 		}
 	})
 
@@ -131,7 +120,8 @@ func TestDummySequencer_GetNextBatch(t *testing.T) {
 
 func TestDummySequencer_VerifyBatch(t *testing.T) {
 	seq := NewDummySequencer()
-	ctx := context.Background()
+	seq.SetBatchSubmissionChan(make(chan Batch, 1))
+	ctx := t.Context()
 
 	// The dummy implementation always returns true regardless of input
 	rollupID := []byte("test-rollup")
@@ -156,7 +146,7 @@ func TestDummySequencer_VerifyBatch(t *testing.T) {
 
 func TestDummySequencer_Concurrency(t *testing.T) {
 	seq := NewDummySequencer()
-	ctx := context.Background()
+	ctx := t.Context()
 
 	// Test concurrent submissions and retrievals
 	const numGoroutines = 10
@@ -165,6 +155,7 @@ func TestDummySequencer_Concurrency(t *testing.T) {
 	// Create a wait group to wait for all goroutines to finish
 	done := make(chan struct{})
 	errors := make(chan error, numGoroutines*numOperationsPerGoroutine)
+	seq.SetBatchSubmissionChan(make(chan Batch, numGoroutines*numOperationsPerGoroutine))
 
 	for i := 0; i < numGoroutines; i++ {
 		go func(routineID int) {
@@ -228,7 +219,9 @@ func TestDummySequencer_Concurrency(t *testing.T) {
 
 func TestDummySequencer_MultipleRollups(t *testing.T) {
 	seq := NewDummySequencer()
-	ctx := context.Background()
+	seq.SetBatchSubmissionChan(make(chan Batch, 3))
+
+	ctx := t.Context()
 
 	// Create multiple rollup IDs and batches
 	rollupIDs := [][]byte{
@@ -271,7 +264,8 @@ func TestDummySequencer_MultipleRollups(t *testing.T) {
 
 func TestDummySequencer_BatchOverwrite(t *testing.T) {
 	seq := NewDummySequencer()
-	ctx := context.Background()
+	seq.SetBatchSubmissionChan(make(chan Batch, 3))
+	ctx := t.Context()
 
 	rollupID := []byte("test-rollup")
 
@@ -323,8 +317,3 @@ func TestDummySequencer_BatchOverwrite(t *testing.T) {
 		t.Fatal("Retrieved batch should not be the first submitted one")
 	}
 }
-
-// Helper function to check if a string contains a substring
-func contains(s, substr string) bool {
-	return strings.Contains(s, substr)
-}