Touches up the responder tests.

op-challenger/fault/abi_test.go

@@ -55,7 +55,7 @@ func TestBuildFaultDefendData(t *testing.T) {
 	_, opts, _, contract, err := setupFaultDisputeGame()
 	require.NoError(t, err)
 
-	responder, _ := newTestFaultResponder(t, false)
+	responder, _ := newTestFaultResponder(t)
 
 	data, err := responder.buildFaultDefendData(1, [32]byte{0x02, 0x03})
 	require.NoError(t, err)
@@ -72,7 +72,7 @@ func TestBuildFaultAttackData(t *testing.T) {
 	_, opts, _, contract, err := setupFaultDisputeGame()
 	require.NoError(t, err)
 
-	responder, _ := newTestFaultResponder(t, false)
+	responder, _ := newTestFaultResponder(t)
 
 	data, err := responder.buildFaultAttackData(1, [32]byte{0x02, 0x03})
 	require.NoError(t, err)
@@ -89,7 +89,7 @@ func TestBuildFaultStepData(t *testing.T) {
 	_, opts, _, contract, err := setupFaultDisputeGame()
 	require.NoError(t, err)
 
-	responder, _ := newTestFaultResponder(t, false)
+	responder, _ := newTestFaultResponder(t)
 
 	data, err := responder.buildStepTxData(types.StepCallData{
 		ClaimIndex: 2,

op-challenger/fault/responder_test.go

@@ -22,13 +22,125 @@ import (
 var (
 	mockFdgAddress = common.HexToAddress("0x1234")
 	mockSendError  = errors.New("mock send error")
+	mockCallError  = errors.New("mock call error")
 )
 
+// TestCanResolve tests the [Responder.CanResolve].
+func TestCanResolve(t *testing.T) {
+	t.Run("SendFails", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		mockTxMgr.callFails = true
+		require.False(t, responder.CanResolve(context.Background()))
+		require.Equal(t, 0, mockTxMgr.calls)
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		require.True(t, responder.CanResolve(context.Background()))
+		require.Equal(t, 1, mockTxMgr.calls)
+	})
+}
+
+// TestResolve tests the [Responder.Resolve] method.
+func TestResolve(t *testing.T) {
+	t.Run("SendFails", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		mockTxMgr.sendFails = true
+		err := responder.Resolve(context.Background())
+		require.ErrorIs(t, err, mockSendError)
+		require.Equal(t, 0, mockTxMgr.sends)
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		err := responder.Resolve(context.Background())
+		require.NoError(t, err)
+		require.Equal(t, 1, mockTxMgr.sends)
+	})
+}
+
+// TestRespond tests the [Responder.Respond] method.
+func TestRespond(t *testing.T) {
+	t.Run("send fails", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		mockTxMgr.sendFails = true
+		err := responder.Respond(context.Background(), generateMockResponseClaim())
+		require.ErrorIs(t, err, mockSendError)
+		require.Equal(t, 0, mockTxMgr.sends)
+	})
+
+	t.Run("sends response", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		err := responder.Respond(context.Background(), generateMockResponseClaim())
+		require.NoError(t, err)
+		require.Equal(t, 1, mockTxMgr.sends)
+	})
+}
+
+// TestBuildTx tests the [Responder.BuildTx] method.
+func TestBuildTx(t *testing.T) {
+	t.Run("attack", func(t *testing.T) {
+		responder, _ := newTestFaultResponder(t)
+		responseClaim := generateMockResponseClaim()
+		responseClaim.ParentContractIndex = 7
+		tx, err := responder.BuildTx(context.Background(), responseClaim)
+		require.NoError(t, err)
+
+		// Pack the tx data manually.
+		fdgAbi, err := bindings.FaultDisputeGameMetaData.GetAbi()
+		require.NoError(t, err)
+		parent := big.NewInt(int64(7))
+		claim := responseClaim.ValueBytes()
+		expected, err := fdgAbi.Pack("attack", parent, claim)
+
+		require.NoError(t, err)
+		require.Equal(t, expected, tx)
+	})
+
+	t.Run("defend", func(t *testing.T) {
+		responder, _ := newTestFaultResponder(t)
+		responseClaim := types.Claim{
+			ClaimData: types.ClaimData{
+				Value:    common.Hash{0x01},
+				Position: types.NewPositionFromGIndex(3),
+			},
+			Parent: types.ClaimData{
+				Value:    common.Hash{0x02},
+				Position: types.NewPositionFromGIndex(6),
+			},
+			ContractIndex:       0,
+			ParentContractIndex: 7,
+		}
+		tx, err := responder.BuildTx(context.Background(), responseClaim)
+		require.NoError(t, err)
+
+		// Pack the tx data manually.
+		fdgAbi, err := bindings.FaultDisputeGameMetaData.GetAbi()
+		require.NoError(t, err)
+		parent := big.NewInt(int64(7))
+		claim := responseClaim.ValueBytes()
+		expected, err := fdgAbi.Pack("defend", parent, claim)
+
+		require.NoError(t, err)
+		require.Equal(t, expected, tx)
+	})
+}
+
+func newTestFaultResponder(t *testing.T) (*faultResponder, *mockTxManager) {
+	log := testlog.Logger(t, log.LvlError)
+	mockTxMgr := &mockTxManager{}
+	responder, err := NewFaultResponder(log, mockTxMgr, mockFdgAddress)
+	require.NoError(t, err)
+	return responder, mockTxMgr
+}
+
 type mockTxManager struct {
 	from      common.Address
 	sends     int
 	calls     int
 	sendFails bool
+	callFails bool
+	callBytes []byte
 }
 
 func (m *mockTxManager) Send(ctx context.Context, candidate txmgr.TxCandidate) (*ethtypes.Receipt, error) {
@@ -44,11 +156,16 @@ func (m *mockTxManager) Send(ctx context.Context, candidate txmgr.TxCandidate) (
 }
 
 func (m *mockTxManager) Call(_ context.Context, _ ethereum.CallMsg, _ *big.Int) ([]byte, error) {
-	if m.sendFails {
-		return nil, mockSendError
+	if m.callFails {
+		return nil, mockCallError
 	}
 	m.calls++
-	return []byte{}, nil
+	if m.callBytes != nil {
+		return m.callBytes, nil
+	}
+	return common.Hex2Bytes(
+		"0000000000000000000000000000000000000000000000000000000000000000",
+	), nil
 }
 
 func (m *mockTxManager) BlockNumber(ctx context.Context) (uint64, error) {
@@ -59,56 +176,8 @@ func (m *mockTxManager) From() common.Address {
 	return m.from
 }
 
-func newTestFaultResponder(t *testing.T, sendFails bool) (*faultResponder, *mockTxManager) {
-	log := testlog.Logger(t, log.LvlError)
-	mockTxMgr := &mockTxManager{}
-	mockTxMgr.sendFails = sendFails
-	responder, err := NewFaultResponder(log, mockTxMgr, mockFdgAddress)
-	require.NoError(t, err)
-	return responder, mockTxMgr
-}
-
-// TestResponder_CanResolve_CallFails tests the [Responder.CanResolve] method
-// bubbles up the error returned by the [txmgr.Call] method.
-func TestResponder_CanResolve_CallFails(t *testing.T) {
-	responder, mockTxMgr := newTestFaultResponder(t, true)
-	resolved := responder.CanResolve(context.Background())
-	require.False(t, resolved)
-	require.Equal(t, 0, mockTxMgr.sends)
-}
-
-// TestResponder_CanResolve_Success tests the [Responder.CanResolve] method
-// succeeds when the call message is successfully sent through the txmgr.
-func TestResponder_CanResolve_Success(t *testing.T) {
-	responder, mockTxMgr := newTestFaultResponder(t, false)
-	resolved := responder.CanResolve(context.Background())
-	require.True(t, resolved)
-	require.Equal(t, 1, mockTxMgr.calls)
-}
-
-// TestResponder_Resolve_SendFails tests the [Responder.Resolve] method
-// bubbles up the error returned by the [txmgr.Send] method.
-func TestResponder_Resolve_SendFails(t *testing.T) {
-	responder, mockTxMgr := newTestFaultResponder(t, true)
-	err := responder.Resolve(context.Background())
-	require.ErrorIs(t, err, mockSendError)
-	require.Equal(t, 0, mockTxMgr.sends)
-}
-
-// TestResponder_Resolve_Success tests the [Responder.Resolve] method
-// succeeds when the tx candidate is successfully sent through the txmgr.
-func TestResponder_Resolve_Success(t *testing.T) {
-	responder, mockTxMgr := newTestFaultResponder(t, false)
-	err := responder.Resolve(context.Background())
-	require.NoError(t, err)
-	require.Equal(t, 1, mockTxMgr.sends)
-}
-
-// TestResponder_Respond_SendFails tests the [Responder.Respond] method
-// bubbles up the error returned by the [txmgr.Send] method.
-func TestResponder_Respond_SendFails(t *testing.T) {
-	responder, mockTxMgr := newTestFaultResponder(t, true)
-	err := responder.Respond(context.Background(), types.Claim{
+func generateMockResponseClaim() types.Claim {
+	return types.Claim{
 		ClaimData: types.ClaimData{
 			Value:    common.Hash{0x01},
 			Position: types.NewPositionFromGIndex(2),
@@ -119,89 +188,5 @@ func TestResponder_Respond_SendFails(t *testing.T) {
 		},
 		ContractIndex:       0,
 		ParentContractIndex: 0,
-	})
-	require.ErrorIs(t, err, mockSendError)
-	require.Equal(t, 0, mockTxMgr.sends)
-}
-
-// TestResponder_Respond_Success tests the [Responder.Respond] method
-// succeeds when the tx candidate is successfully sent through the txmgr.
-func TestResponder_Respond_Success(t *testing.T) {
-	responder, mockTxMgr := newTestFaultResponder(t, false)
-	err := responder.Respond(context.Background(), types.Claim{
-		ClaimData: types.ClaimData{
-			Value:    common.Hash{0x01},
-			Position: types.NewPositionFromGIndex(2),
-		},
-		Parent: types.ClaimData{
-			Value:    common.Hash{0x02},
-			Position: types.NewPositionFromGIndex(1),
-		},
-		ContractIndex:       0,
-		ParentContractIndex: 0,
-	})
-	require.NoError(t, err)
-	require.Equal(t, 1, mockTxMgr.sends)
-}
-
-// TestResponder_BuildTx_Attack tests the [Responder.BuildTx] method
-// returns a tx candidate with the correct data for an attack tx.
-func TestResponder_BuildTx_Attack(t *testing.T) {
-	responder, _ := newTestFaultResponder(t, false)
-	responseClaim := types.Claim{
-		ClaimData: types.ClaimData{
-			Value:    common.Hash{0x01},
-			Position: types.NewPositionFromGIndex(2),
-		},
-		Parent: types.ClaimData{
-			Value:    common.Hash{0x02},
-			Position: types.NewPositionFromGIndex(1),
-		},
-		ContractIndex:       0,
-		ParentContractIndex: 7,
-	}
-	tx, err := responder.BuildTx(context.Background(), responseClaim)
-	require.NoError(t, err)
-
-	// Pack the tx data manually.
-	fdgAbi, err := bindings.FaultDisputeGameMetaData.GetAbi()
-	require.NoError(t, err)
-	expected, err := fdgAbi.Pack(
-		"attack",
-		big.NewInt(int64(7)),
-		responseClaim.ValueBytes(),
-	)
-	require.NoError(t, err)
-	require.Equal(t, expected, tx)
-}
-
-// TestResponder_BuildTx_Defend tests the [Responder.BuildTx] method
-// returns a tx candidate with the correct data for a defend tx.
-func TestResponder_BuildTx_Defend(t *testing.T) {
-	responder, _ := newTestFaultResponder(t, false)
-	responseClaim := types.Claim{
-		ClaimData: types.ClaimData{
-			Value:    common.Hash{0x01},
-			Position: types.NewPositionFromGIndex(3),
-		},
-		Parent: types.ClaimData{
-			Value:    common.Hash{0x02},
-			Position: types.NewPositionFromGIndex(6),
-		},
-		ContractIndex:       0,
-		ParentContractIndex: 7,
 	}
-	tx, err := responder.BuildTx(context.Background(), responseClaim)
-	require.NoError(t, err)
-
-	// Pack the tx data manually.
-	fdgAbi, err := bindings.FaultDisputeGameMetaData.GetAbi()
-	require.NoError(t, err)
-	expected, err := fdgAbi.Pack(
-		"defend",
-		big.NewInt(int64(7)),
-		responseClaim.ValueBytes(),
-	)
-	require.NoError(t, err)
-	require.Equal(t, expected, tx)
 }