feat: gamemaster

2026-05-03 07:59:03 +02:00
parent a7cee15115
commit 3e2622757e
229 changed files with 41521 additions and 1098 deletions
@@ -0,0 +1,598 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: galaxy/gamemaster/internal/api/internalhttp/handlers (interfaces: RegisterRuntimeService,ForceNextTurnService,StopRuntimeService,PatchRuntimeService,BanishRaceService,LivenessService,CommandExecuteService,OrderPutService,ReportGetService,MembershipInvalidator,EngineVersionService,RuntimeRecordsReader)
+//
+// Generated by this command:
+//
+//	mockgen -destination=./mocks/mock_services.go -package=mocks galaxy/gamemaster/internal/api/internalhttp/handlers RegisterRuntimeService,ForceNextTurnService,StopRuntimeService,PatchRuntimeService,BanishRaceService,LivenessService,CommandExecuteService,OrderPutService,ReportGetService,MembershipInvalidator,EngineVersionService,RuntimeRecordsReader
+//
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	context "context"
+	engineversion "galaxy/gamemaster/internal/domain/engineversion"
+	runtime "galaxy/gamemaster/internal/domain/runtime"
+	adminbanish "galaxy/gamemaster/internal/service/adminbanish"
+	adminforce "galaxy/gamemaster/internal/service/adminforce"
+	adminpatch "galaxy/gamemaster/internal/service/adminpatch"
+	adminstop "galaxy/gamemaster/internal/service/adminstop"
+	commandexecute "galaxy/gamemaster/internal/service/commandexecute"
+	engineversion0 "galaxy/gamemaster/internal/service/engineversion"
+	livenessreply "galaxy/gamemaster/internal/service/livenessreply"
+	orderput "galaxy/gamemaster/internal/service/orderput"
+	registerruntime "galaxy/gamemaster/internal/service/registerruntime"
+	reportget "galaxy/gamemaster/internal/service/reportget"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockRegisterRuntimeService is a mock of RegisterRuntimeService interface.
+type MockRegisterRuntimeService struct {
+	ctrl     *gomock.Controller
+	recorder *MockRegisterRuntimeServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockRegisterRuntimeServiceMockRecorder is the mock recorder for MockRegisterRuntimeService.
+type MockRegisterRuntimeServiceMockRecorder struct {
+	mock *MockRegisterRuntimeService
+}
+
+// NewMockRegisterRuntimeService creates a new mock instance.
+func NewMockRegisterRuntimeService(ctrl *gomock.Controller) *MockRegisterRuntimeService {
+	mock := &MockRegisterRuntimeService{ctrl: ctrl}
+	mock.recorder = &MockRegisterRuntimeServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRegisterRuntimeService) EXPECT() *MockRegisterRuntimeServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockRegisterRuntimeService) Handle(ctx context.Context, in registerruntime.Input) (registerruntime.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(registerruntime.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockRegisterRuntimeServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockRegisterRuntimeService)(nil).Handle), ctx, in)
+}
+
+// MockForceNextTurnService is a mock of ForceNextTurnService interface.
+type MockForceNextTurnService struct {
+	ctrl     *gomock.Controller
+	recorder *MockForceNextTurnServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockForceNextTurnServiceMockRecorder is the mock recorder for MockForceNextTurnService.
+type MockForceNextTurnServiceMockRecorder struct {
+	mock *MockForceNextTurnService
+}
+
+// NewMockForceNextTurnService creates a new mock instance.
+func NewMockForceNextTurnService(ctrl *gomock.Controller) *MockForceNextTurnService {
+	mock := &MockForceNextTurnService{ctrl: ctrl}
+	mock.recorder = &MockForceNextTurnServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockForceNextTurnService) EXPECT() *MockForceNextTurnServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockForceNextTurnService) Handle(ctx context.Context, in adminforce.Input) (adminforce.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(adminforce.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockForceNextTurnServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockForceNextTurnService)(nil).Handle), ctx, in)
+}
+
+// MockStopRuntimeService is a mock of StopRuntimeService interface.
+type MockStopRuntimeService struct {
+	ctrl     *gomock.Controller
+	recorder *MockStopRuntimeServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockStopRuntimeServiceMockRecorder is the mock recorder for MockStopRuntimeService.
+type MockStopRuntimeServiceMockRecorder struct {
+	mock *MockStopRuntimeService
+}
+
+// NewMockStopRuntimeService creates a new mock instance.
+func NewMockStopRuntimeService(ctrl *gomock.Controller) *MockStopRuntimeService {
+	mock := &MockStopRuntimeService{ctrl: ctrl}
+	mock.recorder = &MockStopRuntimeServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStopRuntimeService) EXPECT() *MockStopRuntimeServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockStopRuntimeService) Handle(ctx context.Context, in adminstop.Input) (adminstop.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(adminstop.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockStopRuntimeServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockStopRuntimeService)(nil).Handle), ctx, in)
+}
+
+// MockPatchRuntimeService is a mock of PatchRuntimeService interface.
+type MockPatchRuntimeService struct {
+	ctrl     *gomock.Controller
+	recorder *MockPatchRuntimeServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockPatchRuntimeServiceMockRecorder is the mock recorder for MockPatchRuntimeService.
+type MockPatchRuntimeServiceMockRecorder struct {
+	mock *MockPatchRuntimeService
+}
+
+// NewMockPatchRuntimeService creates a new mock instance.
+func NewMockPatchRuntimeService(ctrl *gomock.Controller) *MockPatchRuntimeService {
+	mock := &MockPatchRuntimeService{ctrl: ctrl}
+	mock.recorder = &MockPatchRuntimeServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPatchRuntimeService) EXPECT() *MockPatchRuntimeServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockPatchRuntimeService) Handle(ctx context.Context, in adminpatch.Input) (adminpatch.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(adminpatch.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockPatchRuntimeServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockPatchRuntimeService)(nil).Handle), ctx, in)
+}
+
+// MockBanishRaceService is a mock of BanishRaceService interface.
+type MockBanishRaceService struct {
+	ctrl     *gomock.Controller
+	recorder *MockBanishRaceServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockBanishRaceServiceMockRecorder is the mock recorder for MockBanishRaceService.
+type MockBanishRaceServiceMockRecorder struct {
+	mock *MockBanishRaceService
+}
+
+// NewMockBanishRaceService creates a new mock instance.
+func NewMockBanishRaceService(ctrl *gomock.Controller) *MockBanishRaceService {
+	mock := &MockBanishRaceService{ctrl: ctrl}
+	mock.recorder = &MockBanishRaceServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBanishRaceService) EXPECT() *MockBanishRaceServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockBanishRaceService) Handle(ctx context.Context, in adminbanish.Input) (adminbanish.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(adminbanish.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockBanishRaceServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockBanishRaceService)(nil).Handle), ctx, in)
+}
+
+// MockLivenessService is a mock of LivenessService interface.
+type MockLivenessService struct {
+	ctrl     *gomock.Controller
+	recorder *MockLivenessServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockLivenessServiceMockRecorder is the mock recorder for MockLivenessService.
+type MockLivenessServiceMockRecorder struct {
+	mock *MockLivenessService
+}
+
+// NewMockLivenessService creates a new mock instance.
+func NewMockLivenessService(ctrl *gomock.Controller) *MockLivenessService {
+	mock := &MockLivenessService{ctrl: ctrl}
+	mock.recorder = &MockLivenessServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockLivenessService) EXPECT() *MockLivenessServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockLivenessService) Handle(ctx context.Context, in livenessreply.Input) (livenessreply.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(livenessreply.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockLivenessServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockLivenessService)(nil).Handle), ctx, in)
+}
+
+// MockCommandExecuteService is a mock of CommandExecuteService interface.
+type MockCommandExecuteService struct {
+	ctrl     *gomock.Controller
+	recorder *MockCommandExecuteServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockCommandExecuteServiceMockRecorder is the mock recorder for MockCommandExecuteService.
+type MockCommandExecuteServiceMockRecorder struct {
+	mock *MockCommandExecuteService
+}
+
+// NewMockCommandExecuteService creates a new mock instance.
+func NewMockCommandExecuteService(ctrl *gomock.Controller) *MockCommandExecuteService {
+	mock := &MockCommandExecuteService{ctrl: ctrl}
+	mock.recorder = &MockCommandExecuteServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCommandExecuteService) EXPECT() *MockCommandExecuteServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockCommandExecuteService) Handle(ctx context.Context, in commandexecute.Input) (commandexecute.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(commandexecute.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockCommandExecuteServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockCommandExecuteService)(nil).Handle), ctx, in)
+}
+
+// MockOrderPutService is a mock of OrderPutService interface.
+type MockOrderPutService struct {
+	ctrl     *gomock.Controller
+	recorder *MockOrderPutServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockOrderPutServiceMockRecorder is the mock recorder for MockOrderPutService.
+type MockOrderPutServiceMockRecorder struct {
+	mock *MockOrderPutService
+}
+
+// NewMockOrderPutService creates a new mock instance.
+func NewMockOrderPutService(ctrl *gomock.Controller) *MockOrderPutService {
+	mock := &MockOrderPutService{ctrl: ctrl}
+	mock.recorder = &MockOrderPutServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockOrderPutService) EXPECT() *MockOrderPutServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockOrderPutService) Handle(ctx context.Context, in orderput.Input) (orderput.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(orderput.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockOrderPutServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockOrderPutService)(nil).Handle), ctx, in)
+}
+
+// MockReportGetService is a mock of ReportGetService interface.
+type MockReportGetService struct {
+	ctrl     *gomock.Controller
+	recorder *MockReportGetServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockReportGetServiceMockRecorder is the mock recorder for MockReportGetService.
+type MockReportGetServiceMockRecorder struct {
+	mock *MockReportGetService
+}
+
+// NewMockReportGetService creates a new mock instance.
+func NewMockReportGetService(ctrl *gomock.Controller) *MockReportGetService {
+	mock := &MockReportGetService{ctrl: ctrl}
+	mock.recorder = &MockReportGetServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockReportGetService) EXPECT() *MockReportGetServiceMockRecorder {
+	return m.recorder
+}
+
+// Handle mocks base method.
+func (m *MockReportGetService) Handle(ctx context.Context, in reportget.Input) (reportget.Result, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Handle", ctx, in)
+	ret0, _ := ret[0].(reportget.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Handle indicates an expected call of Handle.
+func (mr *MockReportGetServiceMockRecorder) Handle(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockReportGetService)(nil).Handle), ctx, in)
+}
+
+// MockMembershipInvalidator is a mock of MembershipInvalidator interface.
+type MockMembershipInvalidator struct {
+	ctrl     *gomock.Controller
+	recorder *MockMembershipInvalidatorMockRecorder
+	isgomock struct{}
+}
+
+// MockMembershipInvalidatorMockRecorder is the mock recorder for MockMembershipInvalidator.
+type MockMembershipInvalidatorMockRecorder struct {
+	mock *MockMembershipInvalidator
+}
+
+// NewMockMembershipInvalidator creates a new mock instance.
+func NewMockMembershipInvalidator(ctrl *gomock.Controller) *MockMembershipInvalidator {
+	mock := &MockMembershipInvalidator{ctrl: ctrl}
+	mock.recorder = &MockMembershipInvalidatorMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockMembershipInvalidator) EXPECT() *MockMembershipInvalidatorMockRecorder {
+	return m.recorder
+}
+
+// Invalidate mocks base method.
+func (m *MockMembershipInvalidator) Invalidate(gameID string) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Invalidate", gameID)
+}
+
+// Invalidate indicates an expected call of Invalidate.
+func (mr *MockMembershipInvalidatorMockRecorder) Invalidate(gameID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invalidate", reflect.TypeOf((*MockMembershipInvalidator)(nil).Invalidate), gameID)
+}
+
+// MockEngineVersionService is a mock of EngineVersionService interface.
+type MockEngineVersionService struct {
+	ctrl     *gomock.Controller
+	recorder *MockEngineVersionServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockEngineVersionServiceMockRecorder is the mock recorder for MockEngineVersionService.
+type MockEngineVersionServiceMockRecorder struct {
+	mock *MockEngineVersionService
+}
+
+// NewMockEngineVersionService creates a new mock instance.
+func NewMockEngineVersionService(ctrl *gomock.Controller) *MockEngineVersionService {
+	mock := &MockEngineVersionService{ctrl: ctrl}
+	mock.recorder = &MockEngineVersionServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockEngineVersionService) EXPECT() *MockEngineVersionServiceMockRecorder {
+	return m.recorder
+}
+
+// Create mocks base method.
+func (m *MockEngineVersionService) Create(ctx context.Context, in engineversion0.CreateInput) (engineversion.EngineVersion, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", ctx, in)
+	ret0, _ := ret[0].(engineversion.EngineVersion)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create.
+func (mr *MockEngineVersionServiceMockRecorder) Create(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockEngineVersionService)(nil).Create), ctx, in)
+}
+
+// Deprecate mocks base method.
+func (m *MockEngineVersionService) Deprecate(ctx context.Context, in engineversion0.DeprecateInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Deprecate", ctx, in)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Deprecate indicates an expected call of Deprecate.
+func (mr *MockEngineVersionServiceMockRecorder) Deprecate(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deprecate", reflect.TypeOf((*MockEngineVersionService)(nil).Deprecate), ctx, in)
+}
+
+// Get mocks base method.
+func (m *MockEngineVersionService) Get(ctx context.Context, version string) (engineversion.EngineVersion, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", ctx, version)
+	ret0, _ := ret[0].(engineversion.EngineVersion)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockEngineVersionServiceMockRecorder) Get(ctx, version any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockEngineVersionService)(nil).Get), ctx, version)
+}
+
+// List mocks base method.
+func (m *MockEngineVersionService) List(ctx context.Context, statusFilter *engineversion.Status) ([]engineversion.EngineVersion, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", ctx, statusFilter)
+	ret0, _ := ret[0].([]engineversion.EngineVersion)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockEngineVersionServiceMockRecorder) List(ctx, statusFilter any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockEngineVersionService)(nil).List), ctx, statusFilter)
+}
+
+// ResolveImageRef mocks base method.
+func (m *MockEngineVersionService) ResolveImageRef(ctx context.Context, version string) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveImageRef", ctx, version)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ResolveImageRef indicates an expected call of ResolveImageRef.
+func (mr *MockEngineVersionServiceMockRecorder) ResolveImageRef(ctx, version any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveImageRef", reflect.TypeOf((*MockEngineVersionService)(nil).ResolveImageRef), ctx, version)
+}
+
+// Update mocks base method.
+func (m *MockEngineVersionService) Update(ctx context.Context, in engineversion0.UpdateInput) (engineversion.EngineVersion, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", ctx, in)
+	ret0, _ := ret[0].(engineversion.EngineVersion)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Update indicates an expected call of Update.
+func (mr *MockEngineVersionServiceMockRecorder) Update(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockEngineVersionService)(nil).Update), ctx, in)
+}
+
+// MockRuntimeRecordsReader is a mock of RuntimeRecordsReader interface.
+type MockRuntimeRecordsReader struct {
+	ctrl     *gomock.Controller
+	recorder *MockRuntimeRecordsReaderMockRecorder
+	isgomock struct{}
+}
+
+// MockRuntimeRecordsReaderMockRecorder is the mock recorder for MockRuntimeRecordsReader.
+type MockRuntimeRecordsReaderMockRecorder struct {
+	mock *MockRuntimeRecordsReader
+}
+
+// NewMockRuntimeRecordsReader creates a new mock instance.
+func NewMockRuntimeRecordsReader(ctrl *gomock.Controller) *MockRuntimeRecordsReader {
+	mock := &MockRuntimeRecordsReader{ctrl: ctrl}
+	mock.recorder = &MockRuntimeRecordsReaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRuntimeRecordsReader) EXPECT() *MockRuntimeRecordsReaderMockRecorder {
+	return m.recorder
+}
+
+// Get mocks base method.
+func (m *MockRuntimeRecordsReader) Get(ctx context.Context, gameID string) (runtime.RuntimeRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", ctx, gameID)
+	ret0, _ := ret[0].(runtime.RuntimeRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockRuntimeRecordsReaderMockRecorder) Get(ctx, gameID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRuntimeRecordsReader)(nil).Get), ctx, gameID)
+}
+
+// List mocks base method.
+func (m *MockRuntimeRecordsReader) List(ctx context.Context) ([]runtime.RuntimeRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", ctx)
+	ret0, _ := ret[0].([]runtime.RuntimeRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockRuntimeRecordsReaderMockRecorder) List(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRuntimeRecordsReader)(nil).List), ctx)
+}
+
+// ListByStatus mocks base method.
+func (m *MockRuntimeRecordsReader) ListByStatus(ctx context.Context, status runtime.Status) ([]runtime.RuntimeRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListByStatus", ctx, status)
+	ret0, _ := ret[0].([]runtime.RuntimeRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListByStatus indicates an expected call of ListByStatus.
+func (mr *MockRuntimeRecordsReaderMockRecorder) ListByStatus(ctx, status any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByStatus", reflect.TypeOf((*MockRuntimeRecordsReader)(nil).ListByStatus), ctx, status)
+}