Merge pull request #5123 from ethereum-optimism/refcell/batcher/tests

feat(op-batcher): Channel Builder Unit Tests

op-batcher/Makefile

@@ -19,8 +19,18 @@ test:
 lint:
 	golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint -e "errors.As" -e "errors.Is"
 
+fuzz:
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzDurationZero ./batcher
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzDurationTimeoutMaxChannelDuration ./batcher
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzDurationTimeoutZeroMaxChannelDuration ./batcher
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzChannelCloseTimeout ./batcher
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzChannelZeroCloseTimeout ./batcher
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzSeqWindowClose ./batcher
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzSeqWindowZeroTimeoutClose ./batcher
+
 .PHONY: \
 	op-batcher \
 	clean \
 	test \
-	lint
+	lint \
+	fuzz

op-batcher/batcher/channel_builder.go

@@ -129,6 +129,8 @@ type channelBuilder struct {
 	frames []frameData
 }
 
+// newChannelBuilder creates a new channel builder or returns an error if the
+// channel out could not be created.
 func newChannelBuilder(cfg ChannelConfig) (*channelBuilder, error) {
 	co, err := derive.NewChannelOut()
 	if err != nil {
@@ -255,7 +257,7 @@ func (c *channelBuilder) updateTimeout(timeoutBlockNum uint64, reason error) {
 }
 
 // checkTimeout checks if the channel is timed out at the given block number and
-// in this case marks the channel as full, if it wasn't full alredy.
+// in this case marks the channel as full, if it wasn't full already.
 func (c *channelBuilder) checkTimeout(blockNum uint64) {
 	if !c.IsFull() && c.TimedOut(blockNum) {
 		c.setFullErr(c.timeoutReason)

op-batcher/batcher/channel_config_test.go

+package batcher_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-batcher/batcher"
+	"github.com/stretchr/testify/require"
+)
+
+// TestInputThreshold tests the [ChannelConfig.InputThreshold]
+// function using a table-driven testing approach.
+func TestInputThreshold(t *testing.T) {
+	type testInput struct {
+		TargetFrameSize  uint64
+		TargetNumFrames  int
+		ApproxComprRatio float64
+	}
+	type test struct {
+		input     testInput
+		assertion func(uint64)
+	}
+
+	// Construct test cases that test the boundary conditions
+	tests := []test{
+		{
+			input: testInput{
+				TargetFrameSize:  1,
+				TargetNumFrames:  1,
+				ApproxComprRatio: 0.4,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(2), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  1,
+				TargetNumFrames:  100000,
+				ApproxComprRatio: 0.4,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(250_000), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  1,
+				TargetNumFrames:  1,
+				ApproxComprRatio: 1,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(1), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  1,
+				TargetNumFrames:  1,
+				ApproxComprRatio: 2,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(0), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  100000,
+				TargetNumFrames:  1,
+				ApproxComprRatio: 0.4,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(250_000), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  1,
+				TargetNumFrames:  100000,
+				ApproxComprRatio: 0.4,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(250_000), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  100000,
+				TargetNumFrames:  100000,
+				ApproxComprRatio: 0.4,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(25_000_000_000), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  1,
+				TargetNumFrames:  1,
+				ApproxComprRatio: 0.000001,
+			},
+			assertion: func(output uint64) {
+				require.Equal(t, uint64(1_000_000), output)
+			},
+		},
+		{
+			input: testInput{
+				TargetFrameSize:  0,
+				TargetNumFrames:  0,
+				ApproxComprRatio: 0,
+			},
+			assertion: func(output uint64) {
+				// Need to allow for NaN depending on the machine architecture
+				require.True(t, output == uint64(0) || output == uint64(math.NaN()))
+			},
+		},
+	}
+
+	// Validate each test case
+	for _, tt := range tests {
+		config := batcher.ChannelConfig{
+			TargetFrameSize:  tt.input.TargetFrameSize,
+			TargetNumFrames:  tt.input.TargetNumFrames,
+			ApproxComprRatio: tt.input.ApproxComprRatio,
+		}
+		got := config.InputThreshold()
+		tt.assertion(got)
+	}
+}