Skip to content

N
nebula
Commit 35aea1ea authored by refcell's avatar refcell Committed by GitHub
Browse files
Options

feat(op-dispute-mon): pull claim fetching into the extractor (#9569)

parent 5f1b1b21
Hide whitespace changes
Inline Side-by-side
Showing with 93 additions and 202 deletions
op-dispute-mon/mon/detector.go
View file @ 35aea1ea
......@@ -27,15 +27,13 @@ type DetectorMetrics interface {
type detector struct {
logger log.Logger
metrics DetectorMetrics
creator GameCallerCreator
validator OutputValidator
}
func newDetector(logger log.Logger, metrics DetectorMetrics, creator GameCallerCreator, validator OutputValidator) *detector {
func newDetector(logger log.Logger, metrics DetectorMetrics, validator OutputValidator) *detector {
return &detector{
logger: logger,
metrics: metrics,
creator: creator,
validator: validator,
}
}
......
op-dispute-mon/mon/detector_test.go
View file @ 35aea1ea
......@@ -5,9 +5,7 @@ import (
"errors"
"testing"
faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
"github.com/ethereum-optimism/optimism/op-challenger/game/types"
"github.com/ethereum-optimism/optimism/op-dispute-mon/mon/extract"
monTypes "github.com/ethereum-optimism/optimism/op-dispute-mon/mon/types"
"github.com/ethereum-optimism/optimism/op-service/testlog"
"github.com/ethereum/go-ethereum/common"
......@@ -19,39 +17,29 @@ func TestDetector_Detect(t *testing.T) {
t.Parallel()
t.Run("NoGames", func(t *testing.T) {
detector, metrics, _, _, _ := setupDetectorTest(t)
detector, metrics, _, _ := setupDetectorTest(t)
detector.Detect(context.Background(), []monTypes.EnrichedGameData{})
metrics.Equals(t, 0, 0, 0)
metrics.Mapped(t, map[string]int{})
})
t.Run("CheckAgreementFails", func(t *testing.T) {
detector, metrics, creator, rollup, _ := setupDetectorTest(t)
detector, metrics, rollup, _ := setupDetectorTest(t)
rollup.err = errors.New("boom")
creator.caller.status = []types.GameStatus{types.GameStatusInProgress}
creator.caller.rootClaim = []common.Hash{{}}
detector.Detect(context.Background(), []monTypes.EnrichedGameData{{}})
metrics.Equals(t, 1, 0, 0) // Status should still be metriced here!
metrics.Mapped(t, map[string]int{})
})
t.Run("SingleGame", func(t *testing.T) {
detector, metrics, creator, _, _ := setupDetectorTest(t)
creator.caller.status = []types.GameStatus{types.GameStatusInProgress}
creator.caller.rootClaim = []common.Hash{{}}
detector, metrics, _, _ := setupDetectorTest(t)
detector.Detect(context.Background(), []monTypes.EnrichedGameData{{}})
metrics.Equals(t, 1, 0, 0)
metrics.Mapped(t, map[string]int{"in_progress": 1})
})
t.Run("MultipleGames", func(t *testing.T) {
detector, metrics, creator, _, _ := setupDetectorTest(t)
creator.caller.status = []types.GameStatus{
types.GameStatusInProgress,
types.GameStatusInProgress,
types.GameStatusInProgress,
}
creator.caller.rootClaim = []common.Hash{{}, {}, {}}
detector, metrics, _, _ := setupDetectorTest(t)
detector.Detect(context.Background(), []monTypes.EnrichedGameData{{}, {}, {}})
metrics.Equals(t, 3, 0, 0)
metrics.Mapped(t, map[string]int{"in_progress": 3})
......@@ -109,7 +97,7 @@ func TestDetector_RecordBatch(t *testing.T) {
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
monitor, metrics, _, _, _ := setupDetectorTest(t)
monitor, metrics, _, _ := setupDetectorTest(t)
monitor.recordBatch(test.batch)
test.expect(t, metrics)
})
......@@ -117,7 +105,7 @@ func TestDetector_RecordBatch(t *testing.T) {
}
func TestDetector_CheckAgreement_Fails(t *testing.T) {
detector, _, _, rollup, _ := setupDetectorTest(t)
detector, _, rollup, _ := setupDetectorTest(t)
rollup.err = errors.New("boom")
_, err := detector.checkAgreement(context.Background(), common.Address{}, 0, common.Hash{}, types.GameStatusInProgress)
require.ErrorIs(t, err, rollup.err)
......@@ -180,7 +168,7 @@ func TestDetector_CheckAgreement_Succeeds(t *testing.T) {
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
detector, _, _, _, logs := setupDetectorTest(t)
detector, _, _, logs := setupDetectorTest(t)
batch, err := detector.checkAgreement(context.Background(), common.Address{}, 0, test.rootClaim, test.status)
require.NoError(t, err)
test.expectBatch(&batch)
......@@ -201,14 +189,12 @@ func TestDetector_CheckAgreement_Succeeds(t *testing.T) {
}
}
func setupDetectorTest(t *testing.T) (*detector, *mockDetectorMetricer, *mockGameCallerCreator, *stubOutputValidator, *testlog.CapturingHandler) {
func setupDetectorTest(t *testing.T) (*detector, *mockDetectorMetricer, *stubOutputValidator, *testlog.CapturingHandler) {
logger, capturedLogs := testlog.CaptureLogger(t, log.LvlDebug)
metrics := &mockDetectorMetricer{}
caller := &mockGameCaller{}
creator := &mockGameCallerCreator{caller: caller}
validator := &stubOutputValidator{}
detector := newDetector(logger, metrics, creator, validator)
return detector, metrics, creator, validator, capturedLogs
detector := newDetector(logger, metrics, validator)
return detector, metrics, validator, capturedLogs
}
type stubOutputValidator struct {
......@@ -224,48 +210,6 @@ func (s *stubOutputValidator) CheckRootAgreement(ctx context.Context, blockNum u
return rootClaim == mockRootClaim, mockRootClaim, nil
}
type mockGameCallerCreator struct {
calls int
err error
caller *mockGameCaller
}
func (m *mockGameCallerCreator) CreateContract(game types.GameMetadata) (extract.GameCaller, error) {
m.calls++
if m.err != nil {
return nil, m.err
}
return m.caller, nil
}
type mockGameCaller struct {
calls int
claimsCalls int
claims [][]faultTypes.Claim
status []types.GameStatus
rootClaim []common.Hash
err error
claimsErr error
}
func (m *mockGameCaller) GetGameMetadata(ctx context.Context) (uint64, common.Hash, types.GameStatus, error) {
idx := m.calls
m.calls++
if m.err != nil {
return 0, m.rootClaim[idx], m.status[idx], m.err
}
return 0, m.rootClaim[idx], m.status[idx], nil
}
func (m *mockGameCaller) GetAllClaims(ctx context.Context) ([]faultTypes.Claim, error) {
idx := m.claimsCalls
m.claimsCalls++
if m.claimsErr != nil {
return nil, m.claimsErr
}
return m.claims[idx], nil
}
type mockDetectorMetricer struct {
inProgress int
defenderWon int
......
op-dispute-mon/mon/extract/extractor.go
View file @ 35aea1ea
......@@ -33,10 +33,10 @@ func (e *Extractor) Extract(ctx context.Context, blockHash common.Hash, minTimes
if err != nil {
return nil, fmt.Errorf("failed to load games: %w", err)
}
return e.enrichGameMetadata(ctx, games), nil
return e.enrichGames(ctx, games), nil
}
func (e *Extractor) enrichGameMetadata(ctx context.Context, games []gameTypes.GameMetadata) []monTypes.EnrichedGameData {
func (e *Extractor) enrichGames(ctx context.Context, games []gameTypes.GameMetadata) []monTypes.EnrichedGameData {
var enrichedGames []monTypes.EnrichedGameData
for _, game := range games {
caller, err := e.createContract(game)
......@@ -49,11 +49,17 @@ func (e *Extractor) enrichGameMetadata(ctx context.Context, games []gameTypes.Ga
e.logger.Error("failed to fetch game metadata", "err", err)
continue
}
claims, err := caller.GetAllClaims(ctx)
if err != nil {
e.logger.Error("failed to fetch game claims", "err", err)
continue
}
enrichedGames = append(enrichedGames, monTypes.EnrichedGameData{
GameMetadata: game,
L2BlockNumber: l2BlockNum,
RootClaim: rootClaim,
Status: status,
Claims: claims,
})
}
return enrichedGames
......
op-dispute-mon/mon/extract/extractor_test.go
View file @ 35aea1ea
......@@ -35,20 +35,37 @@ func TestExtractor_Extract(t *testing.T) {
require.Len(t, enriched, 0)
require.Equal(t, 1, games.calls)
require.Equal(t, 1, creator.calls)
verifyLogs(t, logs, 1, 0)
require.Equal(t, 0, creator.caller.metadataCalls)
require.Equal(t, 0, creator.caller.claimsCalls)
verifyLogs(t, logs, 1, 0, 0)
})
t.Run("MetadataFetchErrorLog", func(t *testing.T) {
extractor, creator, games, logs := setupExtractorTest(t)
games.games = []gameTypes.GameMetadata{{}}
creator.caller.err = errors.New("boom")
creator.caller.metadataErr = errors.New("boom")
enriched, err := extractor.Extract(context.Background(), common.Hash{}, 0)
require.NoError(t, err)
require.Len(t, enriched, 0)
require.Equal(t, 1, games.calls)
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.calls)
verifyLogs(t, logs, 0, 1)
require.Equal(t, 1, creator.caller.metadataCalls)
require.Equal(t, 0, creator.caller.claimsCalls)
verifyLogs(t, logs, 0, 1, 0)
})
t.Run("ClaimsFetchErrorLog", func(t *testing.T) {
extractor, creator, games, logs := setupExtractorTest(t)
games.games = []gameTypes.GameMetadata{{}}
creator.caller.claimsErr = errors.New("boom")
enriched, err := extractor.Extract(context.Background(), common.Hash{}, 0)
require.NoError(t, err)
require.Len(t, enriched, 0)
require.Equal(t, 1, games.calls)
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.metadataCalls)
require.Equal(t, 1, creator.caller.claimsCalls)
verifyLogs(t, logs, 0, 0, 1)
})
t.Run("Success", func(t *testing.T) {
......@@ -59,11 +76,12 @@ func TestExtractor_Extract(t *testing.T) {
require.Len(t, enriched, 1)
require.Equal(t, 1, games.calls)
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.calls)
require.Equal(t, 1, creator.caller.metadataCalls)
require.Equal(t, 1, creator.caller.claimsCalls)
})
}
func verifyLogs(t *testing.T, logs *testlog.CapturingHandler, createErr int, metadataErr int) {
func verifyLogs(t *testing.T, logs *testlog.CapturingHandler, createErr int, metadataErr int, claimsErr int) {
errorLevelFilter := testlog.NewLevelFilter(log.LevelError)
createMessageFilter := testlog.NewMessageFilter("failed to create game caller")
l := logs.FindLogs(errorLevelFilter, createMessageFilter)
......@@ -71,6 +89,9 @@ func verifyLogs(t *testing.T, logs *testlog.CapturingHandler, createErr int, met
fetchMessageFilter := testlog.NewMessageFilter("failed to fetch game metadata")
l = logs.FindLogs(errorLevelFilter, fetchMessageFilter)
require.Len(t, l, metadataErr)
claimsMessageFilter := testlog.NewMessageFilter("failed to fetch game claims")
l = logs.FindLogs(errorLevelFilter, claimsMessageFilter)
require.Len(t, l, claimsErr)
}
func setupExtractorTest(t *testing.T) (*Extractor, *mockGameCallerCreator, *mockGameFetcher, *testlog.CapturingHandler) {
......@@ -117,23 +138,26 @@ func (m *mockGameCallerCreator) CreateGameCaller(_ gameTypes.GameMetadata) (Game
}
type mockGameCaller struct {
calls int
err error
rootClaim common.Hash
metadataCalls int
metadataErr error
claimsCalls int
claimsErr error
rootClaim common.Hash
claims []faultTypes.Claim
}
func (m *mockGameCaller) GetGameMetadata(_ context.Context) (uint64, common.Hash, types.GameStatus, error) {
m.calls++
if m.err != nil {
return 0, common.Hash{}, 0, m.err
m.metadataCalls++
if m.metadataErr != nil {
return 0, common.Hash{}, 0, m.metadataErr
}
return 0, mockRootClaim, 0, nil
}
func (m *mockGameCaller) GetAllClaims(ctx context.Context) ([]faultTypes.Claim, error) {
m.calls++
if m.err != nil {
return nil, m.err
m.claimsCalls++
if m.claimsErr != nil {
return nil, m.claimsErr
}
return []faultTypes.Claim{{}}, nil
return m.claims, nil
}
op-dispute-mon/mon/forecast.go
View file @ 35aea1ea
......@@ -26,15 +26,13 @@ type ForecastMetrics interface {
type forecast struct {
logger log.Logger
metrics ForecastMetrics
creator GameCallerCreator
validator OutputValidator
}
func newForecast(logger log.Logger, metrics ForecastMetrics, creator GameCallerCreator, validator OutputValidator) *forecast {
func newForecast(logger log.Logger, metrics ForecastMetrics, validator OutputValidator) *forecast {
return &forecast{
logger: logger,
metrics: metrics,
creator: creator,
validator: validator,
}
}
......@@ -62,19 +60,8 @@ func (f *forecast) forecastGame(ctx context.Context, game monTypes.EnrichedGameD
return nil
}
loader, err := f.creator.CreateContract(game.GameMetadata)
if err != nil {
return fmt.Errorf("%w: %w", ErrContractCreation, err)
}
// Load all claims for the game.
claims, err := loader.GetAllClaims(ctx)
if err != nil {
return fmt.Errorf("%w: %w", ErrClaimFetch, err)
}
// Create the bidirectional tree of claims.
tree := transform.CreateBidirectionalTree(claims)
tree := transform.CreateBidirectionalTree(game.Claims)
// Compute the resolution status of the game.
status := Resolve(tree)
......
op-dispute-mon/mon/forecast_test.go
View file @ 35aea1ea
......@@ -26,61 +26,18 @@ func TestForecast_Forecast_BasicTests(t *testing.T) {
t.Parallel()
t.Run("NoGames", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
forecast, _, rollup, logs := setupForecastTest(t)
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{})
require.Equal(t, 0, creator.calls)
require.Equal(t, 0, creator.caller.calls)
require.Equal(t, 0, creator.caller.claimsCalls)
require.Equal(t, 0, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
require.Nil(t, logs.FindLog(levelFilter, messageFilter))
})
t.Run("ContractCreationFails", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.err = errors.New("boom")
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}})
require.Equal(t, 1, creator.calls)
require.Equal(t, 0, creator.caller.calls)
require.Equal(t, 0, creator.caller.claimsCalls)
require.Equal(t, 0, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
l := logs.FindLog(levelFilter, messageFilter)
require.NotNil(t, l)
err := l.AttrValue("err")
expectedErr := fmt.Errorf("%w: %w", ErrContractCreation, creator.err)
require.Equal(t, expectedErr, err)
})
t.Run("ClaimsFetchFails", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.claimsErr = errors.New("boom")
creator.caller.rootClaim = []common.Hash{mockRootClaim}
creator.caller.status = []types.GameStatus{types.GameStatusInProgress}
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}})
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
require.Equal(t, 0, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
l := logs.FindLog(levelFilter, messageFilter)
require.NotNil(t, l)
err := l.AttrValue("err")
expectedErr := fmt.Errorf("%w: %w", ErrClaimFetch, creator.caller.claimsErr)
require.Equal(t, expectedErr, err)
})
t.Run("RollupFetchFails", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
forecast, _, rollup, logs := setupForecastTest(t)
rollup.err = errors.New("boom")
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1]}
creator.caller.rootClaim = []common.Hash{mockRootClaim}
creator.caller.status = []types.GameStatus{types.GameStatusInProgress}
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}})
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
require.Equal(t, 1, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -92,12 +49,9 @@ func TestForecast_Forecast_BasicTests(t *testing.T) {
})
t.Run("ChallengerWonGameSkipped", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1]}
forecast, _, rollup, logs := setupForecastTest(t)
expectedGame := monTypes.EnrichedGameData{Status: types.GameStatusChallengerWon}
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{expectedGame})
require.Equal(t, 0, creator.calls)
require.Equal(t, 0, creator.caller.claimsCalls)
require.Equal(t, 0, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -111,12 +65,9 @@ func TestForecast_Forecast_BasicTests(t *testing.T) {
})
t.Run("DefenderWonGameSkipped", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1]}
forecast, _, rollup, logs := setupForecastTest(t)
expectedGame := monTypes.EnrichedGameData{Status: types.GameStatusDefenderWon}
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{expectedGame})
require.Equal(t, 0, creator.calls)
require.Equal(t, 0, creator.caller.claimsCalls)
require.Equal(t, 0, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -130,12 +81,8 @@ func TestForecast_Forecast_BasicTests(t *testing.T) {
})
t.Run("SingleGame", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.status = []types.GameStatus{types.GameStatusInProgress}
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1]}
forecast, _, rollup, logs := setupForecastTest(t)
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}})
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
require.Equal(t, 1, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -146,13 +93,8 @@ func TestForecast_Forecast_BasicTests(t *testing.T) {
})
t.Run("MultipleGames", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.status = []types.GameStatus{types.GameStatusInProgress, types.GameStatusInProgress, types.GameStatusInProgress}
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1], createDeepClaimList()[:1], createDeepClaimList()[:1]}
creator.caller.rootClaim = []common.Hash{{}, {}, {}}
forecast, _, rollup, logs := setupForecastTest(t)
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}, {}, {}})
require.Equal(t, 3, creator.calls)
require.Equal(t, 3, creator.caller.claimsCalls)
require.Equal(t, 3, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -167,15 +109,13 @@ func TestForecast_Forecast_EndLogs(t *testing.T) {
t.Parallel()
t.Run("AgreeDefenderWins", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1]}
forecast, _, rollup, logs := setupForecastTest(t)
games := []monTypes.EnrichedGameData{{
Status: types.GameStatusInProgress,
RootClaim: mockRootClaim,
Claims: createDeepClaimList()[:1],
}}
forecast.Forecast(context.Background(), games)
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
require.Equal(t, 1, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -193,15 +133,13 @@ func TestForecast_Forecast_EndLogs(t *testing.T) {
})
t.Run("AgreeChallengerWins", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:2]}
forecast, _, rollup, logs := setupForecastTest(t)
games := []monTypes.EnrichedGameData{{
Status: types.GameStatusInProgress,
RootClaim: mockRootClaim,
Claims: createDeepClaimList()[:2],
}}
forecast.Forecast(context.Background(), games)
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
require.Equal(t, 1, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -219,13 +157,11 @@ func TestForecast_Forecast_EndLogs(t *testing.T) {
})
t.Run("DisagreeChallengerWins", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller = &mockGameCaller{status: []types.GameStatus{types.GameStatusInProgress}}
creator.caller.rootClaim = []common.Hash{{}}
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:2]}
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}})
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
forecast, _, rollup, logs := setupForecastTest(t)
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{
Status: types.GameStatusInProgress,
Claims: createDeepClaimList()[:2],
}})
require.Equal(t, 1, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -243,13 +179,11 @@ func TestForecast_Forecast_EndLogs(t *testing.T) {
})
t.Run("DisagreeDefenderWins", func(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller = &mockGameCaller{status: []types.GameStatus{types.GameStatusInProgress}}
creator.caller.rootClaim = []common.Hash{{}}
creator.caller.claims = [][]faultTypes.Claim{createDeepClaimList()[:1]}
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{}})
require.Equal(t, 1, creator.calls)
require.Equal(t, 1, creator.caller.claimsCalls)
forecast, _, rollup, logs := setupForecastTest(t)
forecast.Forecast(context.Background(), []monTypes.EnrichedGameData{{
Status: types.GameStatusInProgress,
Claims: createDeepClaimList()[:1],
}})
require.Equal(t, 1, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -268,8 +202,8 @@ func TestForecast_Forecast_EndLogs(t *testing.T) {
}
func TestForecast_Forecast_MultipleGames(t *testing.T) {
forecast, _, creator, rollup, logs := setupForecastTest(t)
creator.caller.status = []types.GameStatus{
forecast, _, rollup, logs := setupForecastTest(t)
gameStatus := []types.GameStatus{
types.GameStatusChallengerWon,
types.GameStatusInProgress,
types.GameStatusInProgress,
......@@ -280,7 +214,7 @@ func TestForecast_Forecast_MultipleGames(t *testing.T) {
types.GameStatusChallengerWon,
types.GameStatusChallengerWon,
}
creator.caller.claims = [][]faultTypes.Claim{
claims := [][]faultTypes.Claim{
createDeepClaimList()[:1],
createDeepClaimList()[:2],
createDeepClaimList()[:2],
......@@ -291,7 +225,7 @@ func TestForecast_Forecast_MultipleGames(t *testing.T) {
createDeepClaimList()[:1],
createDeepClaimList()[:1],
}
creator.caller.rootClaim = []common.Hash{
rootClaims := []common.Hash{
{},
{},
mockRootClaim,
......@@ -304,12 +238,11 @@ func TestForecast_Forecast_MultipleGames(t *testing.T) {
}
games := make([]monTypes.EnrichedGameData, 9)
for i := range games {
games[i].Status = creator.caller.status[i]
games[i].RootClaim = creator.caller.rootClaim[i]
games[i].Status = gameStatus[i]
games[i].Claims = claims[i]
games[i].RootClaim = rootClaims[i]
}
forecast.Forecast(context.Background(), games)
require.Equal(t, 4, creator.calls)
require.Equal(t, 4, creator.caller.claimsCalls)
require.Equal(t, 4, rollup.calls)
levelFilter := testlog.NewLevelFilter(log.LevelError)
messageFilter := testlog.NewMessageFilter(failedForecastLog)
......@@ -319,13 +252,11 @@ func TestForecast_Forecast_MultipleGames(t *testing.T) {
require.Len(t, logs.FindLogs(levelFilter, messageFilter), 5)
}
func setupForecastTest(t *testing.T) (*forecast, *mockForecastMetrics, *mockGameCallerCreator, *stubOutputValidator, *testlog.CapturingHandler) {
func setupForecastTest(t *testing.T) (*forecast, *mockForecastMetrics, *stubOutputValidator, *testlog.CapturingHandler) {
logger, capturedLogs := testlog.CaptureLogger(t, log.LvlDebug)
validator := &stubOutputValidator{}
caller := &mockGameCaller{rootClaim: []common.Hash{mockRootClaim}}
creator := &mockGameCallerCreator{caller: caller}
metrics := &mockForecastMetrics{}
return newForecast(logger, metrics, creator, validator), metrics, creator, validator, capturedLogs
return newForecast(logger, metrics, validator), metrics, validator, capturedLogs
}
type mockForecastMetrics struct {
......
op-dispute-mon/mon/service.go
View file @ 35aea1ea
......@@ -111,11 +111,11 @@ func (s *Service) initExtractor() {
}
func (s *Service) initForecast(cfg *config.Config) {
s.forecast = newForecast(s.logger, s.metrics, s.game, s.validator)
s.forecast = newForecast(s.logger, s.metrics, s.validator)
}
func (s *Service) initDetector() {
s.detector = newDetector(s.logger, s.metrics, s.game, s.validator)
s.detector = newDetector(s.logger, s.metrics, s.validator)
}
func (s *Service) initOutputRollupClient(ctx context.Context, cfg *config.Config) error {
......
op-dispute-mon/mon/types/types.go
View file @ 35aea1ea
......@@ -11,6 +11,7 @@ type EnrichedGameData struct {
L2BlockNumber uint64
RootClaim common.Hash
Status types.GameStatus
Claims []faultTypes.Claim
}
// BidirectionalTree is a tree of claims represented as a flat list of claims.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment