11package da
22
33import (
4- "bytes"
54 "context"
65 "errors"
76 "math/rand"
@@ -12,6 +11,7 @@ import (
1211
1312 "github.com/cometbft/cometbft/libs/log"
1413 "github.com/stretchr/testify/assert"
14+ "github.com/stretchr/testify/mock"
1515 "github.com/stretchr/testify/require"
1616 "google.golang.org/grpc"
1717 "google.golang.org/grpc/credentials/insecure"
@@ -20,7 +20,7 @@ import (
2020 proxygrpc "github.com/rollkit/go-da/proxy/grpc"
2121 proxyjsonrpc "github.com/rollkit/go-da/proxy/jsonrpc"
2222 goDATest "github.com/rollkit/go-da/test"
23- "github.com/rollkit/rollkit/da/mock "
23+ "github.com/rollkit/rollkit/test/mocks "
2424 testServer "github.com/rollkit/rollkit/test/server"
2525 "github.com/rollkit/rollkit/types"
2626)
@@ -37,6 +37,8 @@ const (
3737
3838 // MockDANamespace is the mock namespace
3939 MockDANamespace = "00000000000000000000000000000000000000000000000000deadbeef"
40+
41+ submitTimeout = 50 * time .Millisecond
4042)
4143
4244// TestMain starts the mock gRPC and JSONRPC DA services
@@ -67,8 +69,8 @@ func TestMain(m *testing.M) {
6769
6870func TestMockDAErrors (t * testing.T ) {
6971 t .Run ("submit_timeout" , func (t * testing.T ) {
70- mockDA := & mock. MockDA {}
71- dalc := NewDAClient (mockDA , - 1 , - 1 , nil , log .TestingLogger ())
72+ mockDA := & mocks. DA {}
73+ dalc := NewDAClient (mockDA , - 1 , - 1 , nil , nil , log .TestingLogger ())
7274 header , _ := types .GetRandomBlock (1 , 0 )
7375 headers := []* types.SignedHeader {header }
7476 var blobs []da.Blob
@@ -78,23 +80,23 @@ func TestMockDAErrors(t *testing.T) {
7880 blobs = append (blobs , headerBytes )
7981 }
8082 // Set up the mock to throw context deadline exceeded
81- mockDA .On ("MaxBlobSize" ).Return (uint64 (1234 ), nil )
83+ mockDA .On ("MaxBlobSize" , mock . Anything ).Return (uint64 (1234 ), nil )
8284 mockDA .
83- On ("Submit" , blobs , float64 (- 1 ), []byte (nil )).
84- After (100 * time . Millisecond ).
85- Return ([]da. ID { bytes . Repeat ([] byte { 0x00 }, 8 )}, nil )
85+ On ("Submit" , mock . Anything , blobs , float64 (- 1 ), []byte (nil )).
86+ After (submitTimeout ).
87+ Return (nil , context . DeadlineExceeded )
8688 doTestSubmitTimeout (t , dalc , headers )
8789 })
8890 t .Run ("max_blob_size_error" , func (t * testing.T ) {
89- mockDA := & mock. MockDA {}
90- dalc := NewDAClient (mockDA , - 1 , - 1 , nil , log .TestingLogger ())
91+ mockDA := & mocks. DA {}
92+ dalc := NewDAClient (mockDA , - 1 , - 1 , nil , nil , log .TestingLogger ())
9193 // Set up the mock to return an error for MaxBlobSize
92- mockDA .On ("MaxBlobSize" ).Return (uint64 (0 ), errors .New ("unable to get DA max blob size" ))
94+ mockDA .On ("MaxBlobSize" , mock . Anything ).Return (uint64 (0 ), errors .New ("unable to get DA max blob size" ))
9395 doTestMaxBlockSizeError (t , dalc )
9496 })
9597 t .Run ("tx_too_large" , func (t * testing.T ) {
96- mockDA := & mock. MockDA {}
97- dalc := NewDAClient (mockDA , - 1 , - 1 , nil , log .TestingLogger ())
98+ mockDA := & mocks. DA {}
99+ dalc := NewDAClient (mockDA , - 1 , - 1 , nil , nil , log .TestingLogger ())
98100 header , _ := types .GetRandomBlock (1 , 0 )
99101 headers := []* types.SignedHeader {header }
100102 var blobs []da.Blob
@@ -104,9 +106,9 @@ func TestMockDAErrors(t *testing.T) {
104106 blobs = append (blobs , headerBytes )
105107 }
106108 // Set up the mock to throw tx too large
107- mockDA .On ("MaxBlobSize" ).Return (uint64 (1234 ), nil )
109+ mockDA .On ("MaxBlobSize" , mock . Anything ).Return (uint64 (1234 ), nil )
108110 mockDA .
109- On ("Submit" , blobs , float64 (- 1 ), []byte (nil )).
111+ On ("Submit" , mock . Anything , blobs , float64 (- 1 ), []byte (nil )).
110112 Return ([]da.ID {}, errors .New ("tx too large" ))
111113 doTestTxTooLargeError (t , dalc , headers )
112114 })
@@ -115,7 +117,7 @@ func TestMockDAErrors(t *testing.T) {
115117func TestSubmitRetrieve (t * testing.T ) {
116118 ctx , cancel := context .WithTimeout (context .Background (), time .Second )
117119 defer cancel ()
118- dummyClient := NewDAClient (goDATest .NewDummyDA (), - 1 , - 1 , nil , log .TestingLogger ())
120+ dummyClient := NewDAClient (goDATest .NewDummyDA (), - 1 , - 1 , nil , nil , log .TestingLogger ())
119121 jsonrpcClient , err := startMockDAClientJSONRPC (ctx )
120122 require .NoError (t , err )
121123 grpcClient := startMockDAClientGRPC ()
@@ -151,15 +153,15 @@ func startMockDAClientGRPC() *DAClient {
151153 if err := client .Start (addr .Host , grpc .WithTransportCredentials (insecure .NewCredentials ())); err != nil {
152154 panic (err )
153155 }
154- return NewDAClient (client , - 1 , - 1 , nil , log .TestingLogger ())
156+ return NewDAClient (client , - 1 , - 1 , nil , nil , log .TestingLogger ())
155157}
156158
157159func startMockDAClientJSONRPC (ctx context.Context ) (* DAClient , error ) {
158160 client , err := proxyjsonrpc .NewClient (ctx , MockDAAddressHTTP , "" )
159161 if err != nil {
160162 return nil , err
161163 }
162- return NewDAClient (& client .DA , - 1 , - 1 , nil , log .TestingLogger ()), nil
164+ return NewDAClient (& client .DA , - 1 , - 1 , nil , nil , log .TestingLogger ()), nil
163165}
164166
165167func doTestSubmitTimeout (t * testing.T , dalc * DAClient , headers []* types.SignedHeader ) {
@@ -170,7 +172,7 @@ func doTestSubmitTimeout(t *testing.T, dalc *DAClient, headers []*types.SignedHe
170172 require .NoError (t , err )
171173
172174 assert := assert .New (t )
173- dalc .SubmitTimeout = 50 * time . Millisecond
175+ dalc .SubmitTimeout = submitTimeout
174176 resp := dalc .SubmitHeaders (ctx , headers , maxBlobSize , - 1 )
175177 assert .Contains (resp .Message , "context deadline exceeded" , "should return context timeout error" )
176178}
@@ -351,3 +353,31 @@ func doTestRetrieveNoBlocksFound(t *testing.T, dalc *DAClient) {
351353 // assert.Contains(result.Message, ErrBlobNotFound.Error())
352354 assert .Equal (StatusError , result .Code )
353355}
356+
357+ func TestSubmitWithOptions (t * testing.T ) {
358+ ctx , cancel := context .WithTimeout (context .Background (), time .Second )
359+ defer cancel ()
360+ dummyClient := NewDAClient (goDATest .NewDummyDA (), - 1 , - 1 , nil , []byte ("option=value" ), log .TestingLogger ())
361+ jsonrpcClient , err := startMockDAClientJSONRPC (ctx )
362+ require .NoError (t , err )
363+ grpcClient := startMockDAClientGRPC ()
364+ require .NoError (t , err )
365+ clients := map [string ]* DAClient {
366+ "dummy" : dummyClient ,
367+ "jsonrpc" : jsonrpcClient ,
368+ "grpc" : grpcClient ,
369+ }
370+ tests := []struct {
371+ name string
372+ f func (t * testing.T , dalc * DAClient )
373+ }{
374+ {"submit_retrieve" , doTestSubmitRetrieve },
375+ }
376+ for name , dalc := range clients {
377+ for _ , tc := range tests {
378+ t .Run (name + "_" + tc .name , func (t * testing.T ) {
379+ tc .f (t , dalc )
380+ })
381+ }
382+ }
383+ }
0 commit comments