anyproto/any-sync
1
0
Fork 0
mirror of https://github.com/anyproto/any-sync.git synced 2025-06-08 05:57:03 +09:00
Code Activity

Regenerate mocks, fix synctree and syncacl tests

Browse source
This commit is contained in:
mcrakhman 2025-02-04 23:45:45 +01:00
parent 0bf102738a
commit d17864b416
No known key found for this signature in database
GPG key ID: DED12CFEF5B8396B
44 changed files with 1428 additions and 1557 deletions
Download patch file Download diff file Expand all files Collapse all files

9
accountservice/mock_accountservice/mock_accountservice.go
View file

@ -21,7 +21,6 @@ import (
type MockService struct {
ctrl *gomock.Controller
recorder *MockServiceMockRecorder
isgomock struct{}
}
// MockServiceMockRecorder is the mock recorder for MockService.
@ -56,17 +55,17 @@ func (mr *MockServiceMockRecorder) Account() *gomock.Call {
}
// Init mocks base method.
func (m *MockService) Init(a *app.App) error {
func (m *MockService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), arg0)
}
// Name mocks base method.

73
acl/mock_acl/mock_acl.go
View file

@ -25,7 +25,6 @@ import (
type MockAclService struct {
ctrl *gomock.Controller
recorder *MockAclServiceMockRecorder
isgomock struct{}
}
// MockAclServiceMockRecorder is the mock recorder for MockAclService.
@ -46,61 +45,61 @@ func (m *MockAclService) EXPECT() *MockAclServiceMockRecorder {
}
// AddRecord mocks base method.
func (m *MockAclService) AddRecord(ctx context.Context, spaceId string, rec *consensusproto.RawRecord, limits acl.Limits) (*consensusproto.RawRecordWithId, error) {
func (m *MockAclService) AddRecord(arg0 context.Context, arg1 string, arg2 *consensusproto.RawRecord, arg3 acl.Limits) (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRecord", ctx, spaceId, rec, limits)
ret := m.ctrl.Call(m, "AddRecord", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRecord indicates an expected call of AddRecord.
func (mr *MockAclServiceMockRecorder) AddRecord(ctx, spaceId, rec, limits any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) AddRecord(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecord", reflect.TypeOf((*MockAclService)(nil).AddRecord), ctx, spaceId, rec, limits)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecord", reflect.TypeOf((*MockAclService)(nil).AddRecord), arg0, arg1, arg2, arg3)
}
// Close mocks base method.
func (m *MockAclService) Close(ctx context.Context) error {
func (m *MockAclService) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockAclServiceMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAclService)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAclService)(nil).Close), arg0)
}
// HasRecord mocks base method.
func (m *MockAclService) HasRecord(ctx context.Context, spaceId, recordId string) (bool, error) {
func (m *MockAclService) HasRecord(arg0 context.Context, arg1, arg2 string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasRecord", ctx, spaceId, recordId)
ret := m.ctrl.Call(m, "HasRecord", arg0, arg1, arg2)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HasRecord indicates an expected call of HasRecord.
func (mr *MockAclServiceMockRecorder) HasRecord(ctx, spaceId, recordId any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) HasRecord(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasRecord", reflect.TypeOf((*MockAclService)(nil).HasRecord), ctx, spaceId, recordId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasRecord", reflect.TypeOf((*MockAclService)(nil).HasRecord), arg0, arg1, arg2)
}
// Init mocks base method.
func (m *MockAclService) Init(a *app.App) error {
func (m *MockAclService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockAclServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAclService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAclService)(nil).Init), arg0)
}
// Name mocks base method.
@ -118,74 +117,74 @@ func (mr *MockAclServiceMockRecorder) Name() *gomock.Call {
}
// OwnerPubKey mocks base method.
func (m *MockAclService) OwnerPubKey(ctx context.Context, spaceId string) (crypto.PubKey, error) {
func (m *MockAclService) OwnerPubKey(arg0 context.Context, arg1 string) (crypto.PubKey, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OwnerPubKey", ctx, spaceId)
ret := m.ctrl.Call(m, "OwnerPubKey", arg0, arg1)
ret0, _ := ret[0].(crypto.PubKey)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// OwnerPubKey indicates an expected call of OwnerPubKey.
func (mr *MockAclServiceMockRecorder) OwnerPubKey(ctx, spaceId any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) OwnerPubKey(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OwnerPubKey", reflect.TypeOf((*MockAclService)(nil).OwnerPubKey), ctx, spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OwnerPubKey", reflect.TypeOf((*MockAclService)(nil).OwnerPubKey), arg0, arg1)
}
// Permissions mocks base method.
func (m *MockAclService) Permissions(ctx context.Context, identity crypto.PubKey, spaceId string) (list.AclPermissions, error) {
func (m *MockAclService) Permissions(arg0 context.Context, arg1 crypto.PubKey, arg2 string) (list.AclPermissions, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Permissions", ctx, identity, spaceId)
ret := m.ctrl.Call(m, "Permissions", arg0, arg1, arg2)
ret0, _ := ret[0].(list.AclPermissions)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Permissions indicates an expected call of Permissions.
func (mr *MockAclServiceMockRecorder) Permissions(ctx, identity, spaceId any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) Permissions(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Permissions", reflect.TypeOf((*MockAclService)(nil).Permissions), ctx, identity, spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Permissions", reflect.TypeOf((*MockAclService)(nil).Permissions), arg0, arg1, arg2)
}
// ReadState mocks base method.
func (m *MockAclService) ReadState(ctx context.Context, spaceId string, f func(*list.AclState) error) error {
func (m *MockAclService) ReadState(arg0 context.Context, arg1 string, arg2 func(*list.AclState) error) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReadState", ctx, spaceId, f)
ret := m.ctrl.Call(m, "ReadState", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// ReadState indicates an expected call of ReadState.
func (mr *MockAclServiceMockRecorder) ReadState(ctx, spaceId, f any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) ReadState(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadState", reflect.TypeOf((*MockAclService)(nil).ReadState), ctx, spaceId, f)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadState", reflect.TypeOf((*MockAclService)(nil).ReadState), arg0, arg1, arg2)
}
// RecordsAfter mocks base method.
func (m *MockAclService) RecordsAfter(ctx context.Context, spaceId, aclHead string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockAclService) RecordsAfter(arg0 context.Context, arg1, arg2 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecordsAfter", ctx, spaceId, aclHead)
ret := m.ctrl.Call(m, "RecordsAfter", arg0, arg1, arg2)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RecordsAfter indicates an expected call of RecordsAfter.
func (mr *MockAclServiceMockRecorder) RecordsAfter(ctx, spaceId, aclHead any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) RecordsAfter(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockAclService)(nil).RecordsAfter), ctx, spaceId, aclHead)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockAclService)(nil).RecordsAfter), arg0, arg1, arg2)
}
// Run mocks base method.
func (m *MockAclService) Run(ctx context.Context) error {
func (m *MockAclService) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockAclServiceMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockAclServiceMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockAclService)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockAclService)(nil).Run), arg0)
}

41
app/debugstat/mock_debugstat/mock_debugstat.go
View file

@ -22,7 +22,6 @@ import (
type MockStatService struct {
ctrl *gomock.Controller
recorder *MockStatServiceMockRecorder
isgomock struct{}
}
// MockStatServiceMockRecorder is the mock recorder for MockStatService.
@ -43,29 +42,29 @@ func (m *MockStatService) EXPECT() *MockStatServiceMockRecorder {
}
// AddProvider mocks base method.
func (m *MockStatService) AddProvider(provider debugstat.StatProvider) {
func (m *MockStatService) AddProvider(arg0 debugstat.StatProvider) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AddProvider", provider)
m.ctrl.Call(m, "AddProvider", arg0)
}
// AddProvider indicates an expected call of AddProvider.
func (mr *MockStatServiceMockRecorder) AddProvider(provider any) *gomock.Call {
func (mr *MockStatServiceMockRecorder) AddProvider(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProvider", reflect.TypeOf((*MockStatService)(nil).AddProvider), provider)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProvider", reflect.TypeOf((*MockStatService)(nil).AddProvider), arg0)
}
// Close mocks base method.
func (m *MockStatService) Close(ctx context.Context) error {
func (m *MockStatService) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockStatServiceMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockStatServiceMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStatService)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStatService)(nil).Close), arg0)
}
// GetStat mocks base method.
@ -83,17 +82,17 @@ func (mr *MockStatServiceMockRecorder) GetStat() *gomock.Call {
}
// Init mocks base method.
func (m *MockStatService) Init(a *app.App) error {
func (m *MockStatService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockStatServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockStatServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockStatService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockStatService)(nil).Init), arg0)
}
// Name mocks base method.
@ -111,27 +110,27 @@ func (mr *MockStatServiceMockRecorder) Name() *gomock.Call {
}
// RemoveProvider mocks base method.
func (m *MockStatService) RemoveProvider(provider debugstat.StatProvider) {
func (m *MockStatService) RemoveProvider(arg0 debugstat.StatProvider) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "RemoveProvider", provider)
m.ctrl.Call(m, "RemoveProvider", arg0)
}
// RemoveProvider indicates an expected call of RemoveProvider.
func (mr *MockStatServiceMockRecorder) RemoveProvider(provider any) *gomock.Call {
func (mr *MockStatServiceMockRecorder) RemoveProvider(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProvider", reflect.TypeOf((*MockStatService)(nil).RemoveProvider), provider)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProvider", reflect.TypeOf((*MockStatService)(nil).RemoveProvider), arg0)
}
// Run mocks base method.
func (m *MockStatService) Run(ctx context.Context) error {
func (m *MockStatService) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockStatServiceMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockStatServiceMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockStatService)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockStatService)(nil).Run), arg0)
}

50
app/ldiff/mock_ldiff/mock_ldiff.go
View file

@ -21,7 +21,6 @@ import (
type MockDiff struct {
ctrl *gomock.Controller
recorder *MockDiffMockRecorder
isgomock struct{}
}
// MockDiffMockRecorder is the mock recorder for MockDiff.
@ -42,9 +41,9 @@ func (m *MockDiff) EXPECT() *MockDiffMockRecorder {
}
// Diff mocks base method.
func (m *MockDiff) Diff(ctx context.Context, dl ldiff.Remote) ([]string, []string, []string, error) {
func (m *MockDiff) Diff(arg0 context.Context, arg1 ldiff.Remote) ([]string, []string, []string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Diff", ctx, dl)
ret := m.ctrl.Call(m, "Diff", arg0, arg1)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].([]string)
ret2, _ := ret[2].([]string)
@ -53,24 +52,24 @@ func (m *MockDiff) Diff(ctx context.Context, dl ldiff.Remote) ([]string, []strin
}
// Diff indicates an expected call of Diff.
func (mr *MockDiffMockRecorder) Diff(ctx, dl any) *gomock.Call {
func (mr *MockDiffMockRecorder) Diff(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Diff", reflect.TypeOf((*MockDiff)(nil).Diff), ctx, dl)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Diff", reflect.TypeOf((*MockDiff)(nil).Diff), arg0, arg1)
}
// Element mocks base method.
func (m *MockDiff) Element(id string) (ldiff.Element, error) {
func (m *MockDiff) Element(arg0 string) (ldiff.Element, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Element", id)
ret := m.ctrl.Call(m, "Element", arg0)
ret0, _ := ret[0].(ldiff.Element)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Element indicates an expected call of Element.
func (mr *MockDiffMockRecorder) Element(id any) *gomock.Call {
func (mr *MockDiffMockRecorder) Element(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Element", reflect.TypeOf((*MockDiff)(nil).Element), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Element", reflect.TypeOf((*MockDiff)(nil).Element), arg0)
}
// Elements mocks base method.
@ -130,55 +129,54 @@ func (mr *MockDiffMockRecorder) Len() *gomock.Call {
}
// Ranges mocks base method.
func (m *MockDiff) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff.RangeResult) ([]ldiff.RangeResult, error) {
func (m *MockDiff) Ranges(arg0 context.Context, arg1 []ldiff.Range, arg2 []ldiff.RangeResult) ([]ldiff.RangeResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Ranges", ctx, ranges, resBuf)
ret := m.ctrl.Call(m, "Ranges", arg0, arg1, arg2)
ret0, _ := ret[0].([]ldiff.RangeResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Ranges indicates an expected call of Ranges.
func (mr *MockDiffMockRecorder) Ranges(ctx, ranges, resBuf any) *gomock.Call {
func (mr *MockDiffMockRecorder) Ranges(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockDiff)(nil).Ranges), ctx, ranges, resBuf)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockDiff)(nil).Ranges), arg0, arg1, arg2)
}
// RemoveId mocks base method.
func (m *MockDiff) RemoveId(id string) error {
func (m *MockDiff) RemoveId(arg0 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RemoveId", id)
ret := m.ctrl.Call(m, "RemoveId", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// RemoveId indicates an expected call of RemoveId.
func (mr *MockDiffMockRecorder) RemoveId(id any) *gomock.Call {
func (mr *MockDiffMockRecorder) RemoveId(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveId", reflect.TypeOf((*MockDiff)(nil).RemoveId), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveId", reflect.TypeOf((*MockDiff)(nil).RemoveId), arg0)
}
// Set mocks base method.
func (m *MockDiff) Set(elements ...ldiff.Element) {
func (m *MockDiff) Set(arg0 ...ldiff.Element) {
m.ctrl.T.Helper()
varargs := []any{}
for _, a := range elements {
for _, a := range arg0 {
varargs = append(varargs, a)
}
m.ctrl.Call(m, "Set", varargs...)
}
// Set indicates an expected call of Set.
func (mr *MockDiffMockRecorder) Set(elements ...any) *gomock.Call {
func (mr *MockDiffMockRecorder) Set(arg0 ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDiff)(nil).Set), elements...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDiff)(nil).Set), arg0...)
}
// MockRemote is a mock of Remote interface.
type MockRemote struct {
ctrl *gomock.Controller
recorder *MockRemoteMockRecorder
isgomock struct{}
}
// MockRemoteMockRecorder is the mock recorder for MockRemote.
@ -199,16 +197,16 @@ func (m *MockRemote) EXPECT() *MockRemoteMockRecorder {
}
// Ranges mocks base method.
func (m *MockRemote) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff.RangeResult) ([]ldiff.RangeResult, error) {
func (m *MockRemote) Ranges(arg0 context.Context, arg1 []ldiff.Range, arg2 []ldiff.RangeResult) ([]ldiff.RangeResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Ranges", ctx, ranges, resBuf)
ret := m.ctrl.Call(m, "Ranges", arg0, arg1, arg2)
ret0, _ := ret[0].([]ldiff.RangeResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Ranges indicates an expected call of Ranges.
func (mr *MockRemoteMockRecorder) Ranges(ctx, ranges, resBuf any) *gomock.Call {
func (mr *MockRemoteMockRecorder) Ranges(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockRemote)(nil).Ranges), ctx, ranges, resBuf)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockRemote)(nil).Ranges), arg0, arg1, arg2)
}

138
commonspace/acl/aclclient/mock_aclclient/mock_aclclient.go
View file

@ -24,7 +24,6 @@ import (
type MockAclJoiningClient struct {
ctrl *gomock.Controller
recorder *MockAclJoiningClientMockRecorder
isgomock struct{}
}
// MockAclJoiningClientMockRecorder is the mock recorder for MockAclJoiningClient.
@ -45,60 +44,60 @@ func (m *MockAclJoiningClient) EXPECT() *MockAclJoiningClientMockRecorder {
}
// AclGetRecords mocks base method.
func (m *MockAclJoiningClient) AclGetRecords(ctx context.Context, spaceId, aclHead string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockAclJoiningClient) AclGetRecords(arg0 context.Context, arg1, arg2 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclGetRecords", ctx, spaceId, aclHead)
ret := m.ctrl.Call(m, "AclGetRecords", arg0, arg1, arg2)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclGetRecords indicates an expected call of AclGetRecords.
func (mr *MockAclJoiningClientMockRecorder) AclGetRecords(ctx, spaceId, aclHead any) *gomock.Call {
func (mr *MockAclJoiningClientMockRecorder) AclGetRecords(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockAclJoiningClient)(nil).AclGetRecords), ctx, spaceId, aclHead)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockAclJoiningClient)(nil).AclGetRecords), arg0, arg1, arg2)
}
// CancelJoin mocks base method.
func (m *MockAclJoiningClient) CancelJoin(ctx context.Context, spaceId string) error {
func (m *MockAclJoiningClient) CancelJoin(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CancelJoin", ctx, spaceId)
ret := m.ctrl.Call(m, "CancelJoin", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// CancelJoin indicates an expected call of CancelJoin.
func (mr *MockAclJoiningClientMockRecorder) CancelJoin(ctx, spaceId any) *gomock.Call {
func (mr *MockAclJoiningClientMockRecorder) CancelJoin(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelJoin", reflect.TypeOf((*MockAclJoiningClient)(nil).CancelJoin), ctx, spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelJoin", reflect.TypeOf((*MockAclJoiningClient)(nil).CancelJoin), arg0, arg1)
}
// CancelRemoveSelf mocks base method.
func (m *MockAclJoiningClient) CancelRemoveSelf(ctx context.Context, spaceId string) error {
func (m *MockAclJoiningClient) CancelRemoveSelf(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CancelRemoveSelf", ctx, spaceId)
ret := m.ctrl.Call(m, "CancelRemoveSelf", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// CancelRemoveSelf indicates an expected call of CancelRemoveSelf.
func (mr *MockAclJoiningClientMockRecorder) CancelRemoveSelf(ctx, spaceId any) *gomock.Call {
func (mr *MockAclJoiningClientMockRecorder) CancelRemoveSelf(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRemoveSelf", reflect.TypeOf((*MockAclJoiningClient)(nil).CancelRemoveSelf), ctx, spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRemoveSelf", reflect.TypeOf((*MockAclJoiningClient)(nil).CancelRemoveSelf), arg0, arg1)
}
// Init mocks base method.
func (m *MockAclJoiningClient) Init(a *app.App) error {
func (m *MockAclJoiningClient) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockAclJoiningClientMockRecorder) Init(a any) *gomock.Call {
func (mr *MockAclJoiningClientMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAclJoiningClient)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAclJoiningClient)(nil).Init), arg0)
}
// Name mocks base method.
@ -116,25 +115,24 @@ func (mr *MockAclJoiningClientMockRecorder) Name() *gomock.Call {
}
// RequestJoin mocks base method.
func (m *MockAclJoiningClient) RequestJoin(ctx context.Context, spaceId string, payload list.RequestJoinPayload) (string, error) {
func (m *MockAclJoiningClient) RequestJoin(arg0 context.Context, arg1 string, arg2 list.RequestJoinPayload) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RequestJoin", ctx, spaceId, payload)
ret := m.ctrl.Call(m, "RequestJoin", arg0, arg1, arg2)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RequestJoin indicates an expected call of RequestJoin.
func (mr *MockAclJoiningClientMockRecorder) RequestJoin(ctx, spaceId, payload any) *gomock.Call {
func (mr *MockAclJoiningClientMockRecorder) RequestJoin(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestJoin", reflect.TypeOf((*MockAclJoiningClient)(nil).RequestJoin), ctx, spaceId, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestJoin", reflect.TypeOf((*MockAclJoiningClient)(nil).RequestJoin), arg0, arg1, arg2)
}
// MockAclSpaceClient is a mock of AclSpaceClient interface.
type MockAclSpaceClient struct {
ctrl *gomock.Controller
recorder *MockAclSpaceClientMockRecorder
isgomock struct{}
}
// MockAclSpaceClientMockRecorder is the mock recorder for MockAclSpaceClient.
@ -155,87 +153,87 @@ func (m *MockAclSpaceClient) EXPECT() *MockAclSpaceClientMockRecorder {
}
// AcceptRequest mocks base method.
func (m *MockAclSpaceClient) AcceptRequest(ctx context.Context, payload list.RequestAcceptPayload) error {
func (m *MockAclSpaceClient) AcceptRequest(arg0 context.Context, arg1 list.RequestAcceptPayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AcceptRequest", ctx, payload)
ret := m.ctrl.Call(m, "AcceptRequest", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AcceptRequest indicates an expected call of AcceptRequest.
func (mr *MockAclSpaceClientMockRecorder) AcceptRequest(ctx, payload any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) AcceptRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptRequest", reflect.TypeOf((*MockAclSpaceClient)(nil).AcceptRequest), ctx, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptRequest", reflect.TypeOf((*MockAclSpaceClient)(nil).AcceptRequest), arg0, arg1)
}
// AddAccounts mocks base method.
func (m *MockAclSpaceClient) AddAccounts(ctx context.Context, add list.AccountsAddPayload) error {
func (m *MockAclSpaceClient) AddAccounts(arg0 context.Context, arg1 list.AccountsAddPayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddAccounts", ctx, add)
ret := m.ctrl.Call(m, "AddAccounts", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AddAccounts indicates an expected call of AddAccounts.
func (mr *MockAclSpaceClientMockRecorder) AddAccounts(ctx, add any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) AddAccounts(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAccounts", reflect.TypeOf((*MockAclSpaceClient)(nil).AddAccounts), ctx, add)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAccounts", reflect.TypeOf((*MockAclSpaceClient)(nil).AddAccounts), arg0, arg1)
}
// AddRecord mocks base method.
func (m *MockAclSpaceClient) AddRecord(ctx context.Context, consRec *consensusproto.RawRecord) error {
func (m *MockAclSpaceClient) AddRecord(arg0 context.Context, arg1 *consensusproto.RawRecord) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRecord", ctx, consRec)
ret := m.ctrl.Call(m, "AddRecord", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AddRecord indicates an expected call of AddRecord.
func (mr *MockAclSpaceClientMockRecorder) AddRecord(ctx, consRec any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) AddRecord(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecord", reflect.TypeOf((*MockAclSpaceClient)(nil).AddRecord), ctx, consRec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecord", reflect.TypeOf((*MockAclSpaceClient)(nil).AddRecord), arg0, arg1)
}
// CancelRequest mocks base method.
func (m *MockAclSpaceClient) CancelRequest(ctx context.Context) error {
func (m *MockAclSpaceClient) CancelRequest(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CancelRequest", ctx)
ret := m.ctrl.Call(m, "CancelRequest", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// CancelRequest indicates an expected call of CancelRequest.
func (mr *MockAclSpaceClientMockRecorder) CancelRequest(ctx any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) CancelRequest(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRequest", reflect.TypeOf((*MockAclSpaceClient)(nil).CancelRequest), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRequest", reflect.TypeOf((*MockAclSpaceClient)(nil).CancelRequest), arg0)
}
// ChangePermissions mocks base method.
func (m *MockAclSpaceClient) ChangePermissions(ctx context.Context, permChange list.PermissionChangesPayload) error {
func (m *MockAclSpaceClient) ChangePermissions(arg0 context.Context, arg1 list.PermissionChangesPayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangePermissions", ctx, permChange)
ret := m.ctrl.Call(m, "ChangePermissions", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// ChangePermissions indicates an expected call of ChangePermissions.
func (mr *MockAclSpaceClientMockRecorder) ChangePermissions(ctx, permChange any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) ChangePermissions(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePermissions", reflect.TypeOf((*MockAclSpaceClient)(nil).ChangePermissions), ctx, permChange)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePermissions", reflect.TypeOf((*MockAclSpaceClient)(nil).ChangePermissions), arg0, arg1)
}
// DeclineRequest mocks base method.
func (m *MockAclSpaceClient) DeclineRequest(ctx context.Context, identity crypto.PubKey) error {
func (m *MockAclSpaceClient) DeclineRequest(arg0 context.Context, arg1 crypto.PubKey) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeclineRequest", ctx, identity)
ret := m.ctrl.Call(m, "DeclineRequest", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// DeclineRequest indicates an expected call of DeclineRequest.
func (mr *MockAclSpaceClientMockRecorder) DeclineRequest(ctx, identity any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) DeclineRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeclineRequest", reflect.TypeOf((*MockAclSpaceClient)(nil).DeclineRequest), ctx, identity)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeclineRequest", reflect.TypeOf((*MockAclSpaceClient)(nil).DeclineRequest), arg0, arg1)
}
// GenerateInvite mocks base method.
@ -254,17 +252,17 @@ func (mr *MockAclSpaceClientMockRecorder) GenerateInvite() *gomock.Call {
}
// Init mocks base method.
func (m *MockAclSpaceClient) Init(a *app.App) error {
func (m *MockAclSpaceClient) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockAclSpaceClientMockRecorder) Init(a any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAclSpaceClient)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAclSpaceClient)(nil).Init), arg0)
}
// Name mocks base method.
@ -282,71 +280,71 @@ func (mr *MockAclSpaceClientMockRecorder) Name() *gomock.Call {
}
// RemoveAccounts mocks base method.
func (m *MockAclSpaceClient) RemoveAccounts(ctx context.Context, payload list.AccountRemovePayload) error {
func (m *MockAclSpaceClient) RemoveAccounts(arg0 context.Context, arg1 list.AccountRemovePayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RemoveAccounts", ctx, payload)
ret := m.ctrl.Call(m, "RemoveAccounts", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// RemoveAccounts indicates an expected call of RemoveAccounts.
func (mr *MockAclSpaceClientMockRecorder) RemoveAccounts(ctx, payload any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) RemoveAccounts(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccounts", reflect.TypeOf((*MockAclSpaceClient)(nil).RemoveAccounts), ctx, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccounts", reflect.TypeOf((*MockAclSpaceClient)(nil).RemoveAccounts), arg0, arg1)
}
// RequestSelfRemove mocks base method.
func (m *MockAclSpaceClient) RequestSelfRemove(ctx context.Context) error {
func (m *MockAclSpaceClient) RequestSelfRemove(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RequestSelfRemove", ctx)
ret := m.ctrl.Call(m, "RequestSelfRemove", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// RequestSelfRemove indicates an expected call of RequestSelfRemove.
func (mr *MockAclSpaceClientMockRecorder) RequestSelfRemove(ctx any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) RequestSelfRemove(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSelfRemove", reflect.TypeOf((*MockAclSpaceClient)(nil).RequestSelfRemove), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSelfRemove", reflect.TypeOf((*MockAclSpaceClient)(nil).RequestSelfRemove), arg0)
}
// RevokeAllInvites mocks base method.
func (m *MockAclSpaceClient) RevokeAllInvites(ctx context.Context) error {
func (m *MockAclSpaceClient) RevokeAllInvites(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RevokeAllInvites", ctx)
ret := m.ctrl.Call(m, "RevokeAllInvites", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// RevokeAllInvites indicates an expected call of RevokeAllInvites.
func (mr *MockAclSpaceClientMockRecorder) RevokeAllInvites(ctx any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) RevokeAllInvites(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeAllInvites", reflect.TypeOf((*MockAclSpaceClient)(nil).RevokeAllInvites), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeAllInvites", reflect.TypeOf((*MockAclSpaceClient)(nil).RevokeAllInvites), arg0)
}
// RevokeInvite mocks base method.
func (m *MockAclSpaceClient) RevokeInvite(ctx context.Context, inviteRecordId string) error {
func (m *MockAclSpaceClient) RevokeInvite(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RevokeInvite", ctx, inviteRecordId)
ret := m.ctrl.Call(m, "RevokeInvite", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// RevokeInvite indicates an expected call of RevokeInvite.
func (mr *MockAclSpaceClientMockRecorder) RevokeInvite(ctx, inviteRecordId any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) RevokeInvite(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeInvite", reflect.TypeOf((*MockAclSpaceClient)(nil).RevokeInvite), ctx, inviteRecordId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeInvite", reflect.TypeOf((*MockAclSpaceClient)(nil).RevokeInvite), arg0, arg1)
}
// StopSharing mocks base method.
func (m *MockAclSpaceClient) StopSharing(ctx context.Context, readKeyChange list.ReadKeyChangePayload) error {
func (m *MockAclSpaceClient) StopSharing(arg0 context.Context, arg1 list.ReadKeyChangePayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StopSharing", ctx, readKeyChange)
ret := m.ctrl.Call(m, "StopSharing", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// StopSharing indicates an expected call of StopSharing.
func (mr *MockAclSpaceClientMockRecorder) StopSharing(ctx, readKeyChange any) *gomock.Call {
func (mr *MockAclSpaceClientMockRecorder) StopSharing(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopSharing", reflect.TypeOf((*MockAclSpaceClient)(nil).StopSharing), ctx, readKeyChange)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopSharing", reflect.TypeOf((*MockAclSpaceClient)(nil).StopSharing), arg0, arg1)
}

17
commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go
View file

@ -22,7 +22,6 @@ import (
type MockCredentialProvider struct {
ctrl *gomock.Controller
recorder *MockCredentialProviderMockRecorder
isgomock struct{}
}
// MockCredentialProviderMockRecorder is the mock recorder for MockCredentialProvider.
@ -43,32 +42,32 @@ func (m *MockCredentialProvider) EXPECT() *MockCredentialProviderMockRecorder {
}
// GetCredential mocks base method.
func (m *MockCredentialProvider) GetCredential(ctx context.Context, spaceHeader *spacesyncproto.RawSpaceHeaderWithId) ([]byte, error) {
func (m *MockCredentialProvider) GetCredential(arg0 context.Context, arg1 *spacesyncproto.RawSpaceHeaderWithId) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetCredential", ctx, spaceHeader)
ret := m.ctrl.Call(m, "GetCredential", arg0, arg1)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetCredential indicates an expected call of GetCredential.
func (mr *MockCredentialProviderMockRecorder) GetCredential(ctx, spaceHeader any) *gomock.Call {
func (mr *MockCredentialProviderMockRecorder) GetCredential(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredential", reflect.TypeOf((*MockCredentialProvider)(nil).GetCredential), ctx, spaceHeader)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredential", reflect.TypeOf((*MockCredentialProvider)(nil).GetCredential), arg0, arg1)
}
// Init mocks base method.
func (m *MockCredentialProvider) Init(a *app.App) error {
func (m *MockCredentialProvider) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockCredentialProviderMockRecorder) Init(a any) *gomock.Call {
func (mr *MockCredentialProviderMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockCredentialProvider)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockCredentialProvider)(nil).Init), arg0)
}
// Name mocks base method.

42
commonspace/deletionmanager/mock_deletionmanager/mock_deletionmanager.go
View file

@ -22,7 +22,6 @@ import (
type MockDeletionManager struct {
ctrl *gomock.Controller
recorder *MockDeletionManagerMockRecorder
isgomock struct{}
}
// MockDeletionManagerMockRecorder is the mock recorder for MockDeletionManager.
@ -43,31 +42,31 @@ func (m *MockDeletionManager) EXPECT() *MockDeletionManagerMockRecorder {
}
// Close mocks base method.
func (m *MockDeletionManager) Close(ctx context.Context) error {
func (m *MockDeletionManager) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockDeletionManagerMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockDeletionManagerMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDeletionManager)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDeletionManager)(nil).Close), arg0)
}
// Init mocks base method.
func (m *MockDeletionManager) Init(a *app.App) error {
func (m *MockDeletionManager) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockDeletionManagerMockRecorder) Init(a any) *gomock.Call {
func (mr *MockDeletionManagerMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockDeletionManager)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockDeletionManager)(nil).Init), arg0)
}
// Name mocks base method.
@ -85,38 +84,37 @@ func (mr *MockDeletionManagerMockRecorder) Name() *gomock.Call {
}
// Run mocks base method.
func (m *MockDeletionManager) Run(ctx context.Context) error {
func (m *MockDeletionManager) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockDeletionManagerMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockDeletionManagerMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockDeletionManager)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockDeletionManager)(nil).Run), arg0)
}
// UpdateState mocks base method.
func (m *MockDeletionManager) UpdateState(ctx context.Context, state *settingsstate.State) error {
func (m *MockDeletionManager) UpdateState(arg0 context.Context, arg1 *settingsstate.State) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateState", ctx, state)
ret := m.ctrl.Call(m, "UpdateState", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// UpdateState indicates an expected call of UpdateState.
func (mr *MockDeletionManagerMockRecorder) UpdateState(ctx, state any) *gomock.Call {
func (mr *MockDeletionManagerMockRecorder) UpdateState(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateState", reflect.TypeOf((*MockDeletionManager)(nil).UpdateState), ctx, state)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateState", reflect.TypeOf((*MockDeletionManager)(nil).UpdateState), arg0, arg1)
}
// MockDeleter is a mock of Deleter interface.
type MockDeleter struct {
ctrl *gomock.Controller
recorder *MockDeleterMockRecorder
isgomock struct{}
}
// MockDeleterMockRecorder is the mock recorder for MockDeleter.
@ -137,13 +135,13 @@ func (m *MockDeleter) EXPECT() *MockDeleterMockRecorder {
}
// Delete mocks base method.
func (m *MockDeleter) Delete(ctx context.Context) {
func (m *MockDeleter) Delete(arg0 context.Context) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Delete", ctx)
m.ctrl.Call(m, "Delete", arg0)
}
// Delete indicates an expected call of Delete.
func (mr *MockDeleterMockRecorder) Delete(ctx any) *gomock.Call {
func (mr *MockDeleterMockRecorder) Delete(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDeleter)(nil).Delete), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDeleter)(nil).Delete), arg0)
}

49
commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go
View file

@ -21,7 +21,6 @@ import (
type MockObjectDeletionState struct {
ctrl *gomock.Controller
recorder *MockObjectDeletionStateMockRecorder
isgomock struct{}
}
// MockObjectDeletionStateMockRecorder is the mock recorder for MockObjectDeletionState.
@ -42,69 +41,69 @@ func (m *MockObjectDeletionState) EXPECT() *MockObjectDeletionStateMockRecorder
}
// Add mocks base method.
func (m *MockObjectDeletionState) Add(ids map[string]struct{}) {
func (m *MockObjectDeletionState) Add(arg0 map[string]struct{}) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Add", ids)
m.ctrl.Call(m, "Add", arg0)
}
// Add indicates an expected call of Add.
func (mr *MockObjectDeletionStateMockRecorder) Add(ids any) *gomock.Call {
func (mr *MockObjectDeletionStateMockRecorder) Add(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockObjectDeletionState)(nil).Add), ids)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockObjectDeletionState)(nil).Add), arg0)
}
// AddObserver mocks base method.
func (m *MockObjectDeletionState) AddObserver(observer deletionstate.StateUpdateObserver) {
func (m *MockObjectDeletionState) AddObserver(arg0 deletionstate.StateUpdateObserver) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AddObserver", observer)
m.ctrl.Call(m, "AddObserver", arg0)
}
// AddObserver indicates an expected call of AddObserver.
func (mr *MockObjectDeletionStateMockRecorder) AddObserver(observer any) *gomock.Call {
func (mr *MockObjectDeletionStateMockRecorder) AddObserver(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockObjectDeletionState)(nil).AddObserver), observer)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockObjectDeletionState)(nil).AddObserver), arg0)
}
// Delete mocks base method.
func (m *MockObjectDeletionState) Delete(id string) error {
func (m *MockObjectDeletionState) Delete(arg0 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", id)
ret := m.ctrl.Call(m, "Delete", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockObjectDeletionStateMockRecorder) Delete(id any) *gomock.Call {
func (mr *MockObjectDeletionStateMockRecorder) Delete(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectDeletionState)(nil).Delete), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectDeletionState)(nil).Delete), arg0)
}
// Exists mocks base method.
func (m *MockObjectDeletionState) Exists(id string) bool {
func (m *MockObjectDeletionState) Exists(arg0 string) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Exists", id)
ret := m.ctrl.Call(m, "Exists", arg0)
ret0, _ := ret[0].(bool)
return ret0
}
// Exists indicates an expected call of Exists.
func (mr *MockObjectDeletionStateMockRecorder) Exists(id any) *gomock.Call {
func (mr *MockObjectDeletionStateMockRecorder) Exists(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockObjectDeletionState)(nil).Exists), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockObjectDeletionState)(nil).Exists), arg0)
}
// Filter mocks base method.
func (m *MockObjectDeletionState) Filter(ids []string) []string {
func (m *MockObjectDeletionState) Filter(arg0 []string) []string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Filter", ids)
ret := m.ctrl.Call(m, "Filter", arg0)
ret0, _ := ret[0].([]string)
return ret0
}
// Filter indicates an expected call of Filter.
func (mr *MockObjectDeletionStateMockRecorder) Filter(ids any) *gomock.Call {
func (mr *MockObjectDeletionStateMockRecorder) Filter(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filter", reflect.TypeOf((*MockObjectDeletionState)(nil).Filter), ids)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filter", reflect.TypeOf((*MockObjectDeletionState)(nil).Filter), arg0)
}
// GetQueued mocks base method.
@ -122,17 +121,17 @@ func (mr *MockObjectDeletionStateMockRecorder) GetQueued() *gomock.Call {
}
// Init mocks base method.
func (m *MockObjectDeletionState) Init(a *app.App) error {
func (m *MockObjectDeletionState) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockObjectDeletionStateMockRecorder) Init(a any) *gomock.Call {
func (mr *MockObjectDeletionStateMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockObjectDeletionState)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockObjectDeletionState)(nil).Init), arg0)
}
// Name mocks base method.

1
commonspace/headsync/headstorage/headstorage.go
View file

@ -1,3 +1,4 @@
//go:generate mockgen -destination mock_headstorage/mock_headstorage.go github.com/anyproto/any-sync/commonspace/headsync/headstorage HeadStorage
package headstorage
import (

124
commonspace/headsync/headstorage/mock_headstorage/mock_headstorage.go Normal file
View file

@ -0,0 +1,124 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/commonspace/headsync/headstorage (interfaces: HeadStorage)
//
// Generated by this command:
//
// mockgen -destination mock_headstorage/mock_headstorage.go github.com/anyproto/any-sync/commonspace/headsync/headstorage HeadStorage
//
// Package mock_headstorage is a generated GoMock package.
package mock_headstorage
import (
context "context"
reflect "reflect"
headstorage "github.com/anyproto/any-sync/commonspace/headsync/headstorage"
gomock "go.uber.org/mock/gomock"
)
// MockHeadStorage is a mock of HeadStorage interface.
type MockHeadStorage struct {
ctrl *gomock.Controller
recorder *MockHeadStorageMockRecorder
}
// MockHeadStorageMockRecorder is the mock recorder for MockHeadStorage.
type MockHeadStorageMockRecorder struct {
mock *MockHeadStorage
}
// NewMockHeadStorage creates a new mock instance.
func NewMockHeadStorage(ctrl *gomock.Controller) *MockHeadStorage {
mock := &MockHeadStorage{ctrl: ctrl}
mock.recorder = &MockHeadStorageMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockHeadStorage) EXPECT() *MockHeadStorageMockRecorder {
return m.recorder
}
// AddObserver mocks base method.
func (m *MockHeadStorage) AddObserver(arg0 headstorage.Observer) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AddObserver", arg0)
}
// AddObserver indicates an expected call of AddObserver.
func (mr *MockHeadStorageMockRecorder) AddObserver(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockHeadStorage)(nil).AddObserver), arg0)
}
// DeleteEntryTx mocks base method.
func (m *MockHeadStorage) DeleteEntryTx(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteEntryTx", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteEntryTx indicates an expected call of DeleteEntryTx.
func (mr *MockHeadStorageMockRecorder) DeleteEntryTx(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEntryTx", reflect.TypeOf((*MockHeadStorage)(nil).DeleteEntryTx), arg0, arg1)
}
// GetEntry mocks base method.
func (m *MockHeadStorage) GetEntry(arg0 context.Context, arg1 string) (headstorage.HeadsEntry, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetEntry", arg0, arg1)
ret0, _ := ret[0].(headstorage.HeadsEntry)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetEntry indicates an expected call of GetEntry.
func (mr *MockHeadStorageMockRecorder) GetEntry(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEntry", reflect.TypeOf((*MockHeadStorage)(nil).GetEntry), arg0, arg1)
}
// IterateEntries mocks base method.
func (m *MockHeadStorage) IterateEntries(arg0 context.Context, arg1 headstorage.IterOpts, arg2 headstorage.EntryIterator) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateEntries", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// IterateEntries indicates an expected call of IterateEntries.
func (mr *MockHeadStorageMockRecorder) IterateEntries(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateEntries", reflect.TypeOf((*MockHeadStorage)(nil).IterateEntries), arg0, arg1, arg2)
}
// UpdateEntry mocks base method.
func (m *MockHeadStorage) UpdateEntry(arg0 context.Context, arg1 headstorage.HeadsUpdate) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateEntry", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// UpdateEntry indicates an expected call of UpdateEntry.
func (mr *MockHeadStorageMockRecorder) UpdateEntry(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEntry", reflect.TypeOf((*MockHeadStorage)(nil).UpdateEntry), arg0, arg1)
}
// UpdateEntryTx mocks base method.
func (m *MockHeadStorage) UpdateEntryTx(arg0 context.Context, arg1 headstorage.HeadsUpdate) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateEntryTx", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// UpdateEntryTx indicates an expected call of UpdateEntryTx.
func (mr *MockHeadStorageMockRecorder) UpdateEntryTx(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEntryTx", reflect.TypeOf((*MockHeadStorage)(nil).UpdateEntryTx), arg0, arg1)
}

45
commonspace/headsync/mock_headsync/mock_headsync.go
View file

@ -20,7 +20,6 @@ import (
type MockDiffSyncer struct {
ctrl *gomock.Controller
recorder *MockDiffSyncerMockRecorder
isgomock struct{}
}
// MockDiffSyncerMockRecorder is the mock recorder for MockDiffSyncer.
@ -40,6 +39,18 @@ func (m *MockDiffSyncer) EXPECT() *MockDiffSyncerMockRecorder {
return m.recorder
}
// Close mocks base method.
func (m *MockDiffSyncer) Close() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Close")
}
// Close indicates an expected call of Close.
func (mr *MockDiffSyncerMockRecorder) Close() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDiffSyncer)(nil).Close))
}
// Init mocks base method.
func (m *MockDiffSyncer) Init() {
m.ctrl.T.Helper()
@ -52,40 +63,16 @@ func (mr *MockDiffSyncerMockRecorder) Init() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockDiffSyncer)(nil).Init))
}
// RemoveObjects mocks base method.
func (m *MockDiffSyncer) RemoveObjects(ids []string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "RemoveObjects", ids)
}
// RemoveObjects indicates an expected call of RemoveObjects.
func (mr *MockDiffSyncerMockRecorder) RemoveObjects(ids any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveObjects", reflect.TypeOf((*MockDiffSyncer)(nil).RemoveObjects), ids)
}
// Sync mocks base method.
func (m *MockDiffSyncer) Sync(ctx context.Context) error {
func (m *MockDiffSyncer) Sync(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Sync", ctx)
ret := m.ctrl.Call(m, "Sync", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Sync indicates an expected call of Sync.
func (mr *MockDiffSyncerMockRecorder) Sync(ctx any) *gomock.Call {
func (mr *MockDiffSyncerMockRecorder) Sync(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockDiffSyncer)(nil).Sync), ctx)
}
// UpdateHeads mocks base method.
func (m *MockDiffSyncer) UpdateHeads(id string, heads []string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdateHeads", id, heads)
}
// UpdateHeads indicates an expected call of UpdateHeads.
func (mr *MockDiffSyncerMockRecorder) UpdateHeads(id, heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHeads", reflect.TypeOf((*MockDiffSyncer)(nil).UpdateHeads), id, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockDiffSyncer)(nil).Sync), arg0)
}

80
commonspace/mock_commonspace/mock_commonspace.go
View file

@ -33,7 +33,6 @@ import (
type MockSpace struct {
ctrl *gomock.Controller
recorder *MockSpaceMockRecorder
isgomock struct{}
}
// MockSpaceMockRecorder is the mock recorder for MockSpace.
@ -110,105 +109,90 @@ func (mr *MockSpaceMockRecorder) DebugAllHeads() *gomock.Call {
}
// DeleteTree mocks base method.
func (m *MockSpace) DeleteTree(ctx context.Context, id string) error {
func (m *MockSpace) DeleteTree(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteTree", ctx, id)
ret := m.ctrl.Call(m, "DeleteTree", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteTree indicates an expected call of DeleteTree.
func (mr *MockSpaceMockRecorder) DeleteTree(ctx, id any) *gomock.Call {
func (mr *MockSpaceMockRecorder) DeleteTree(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockSpace)(nil).DeleteTree), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockSpace)(nil).DeleteTree), arg0, arg1)
}
// Description mocks base method.
func (m *MockSpace) Description() (commonspace.SpaceDescription, error) {
func (m *MockSpace) Description(arg0 context.Context) (commonspace.SpaceDescription, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Description")
ret := m.ctrl.Call(m, "Description", arg0)
ret0, _ := ret[0].(commonspace.SpaceDescription)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Description indicates an expected call of Description.
func (mr *MockSpaceMockRecorder) Description() *gomock.Call {
func (mr *MockSpaceMockRecorder) Description(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockSpace)(nil).Description))
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockSpace)(nil).Description), arg0)
}
// GetNodePeers mocks base method.
func (m *MockSpace) GetNodePeers(ctx context.Context) ([]peer.Peer, error) {
func (m *MockSpace) GetNodePeers(arg0 context.Context) ([]peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNodePeers", ctx)
ret := m.ctrl.Call(m, "GetNodePeers", arg0)
ret0, _ := ret[0].([]peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNodePeers indicates an expected call of GetNodePeers.
func (mr *MockSpaceMockRecorder) GetNodePeers(ctx any) *gomock.Call {
func (mr *MockSpaceMockRecorder) GetNodePeers(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePeers", reflect.TypeOf((*MockSpace)(nil).GetNodePeers), ctx)
}
// HandleDeprecatedObjectSyncRequest mocks base method.
func (m *MockSpace) HandleDeprecatedObjectSyncRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleDeprecatedObjectSyncRequest", ctx, req)
ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleDeprecatedObjectSyncRequest indicates an expected call of HandleDeprecatedObjectSyncRequest.
func (mr *MockSpaceMockRecorder) HandleDeprecatedObjectSyncRequest(ctx, req any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDeprecatedObjectSyncRequest", reflect.TypeOf((*MockSpace)(nil).HandleDeprecatedObjectSyncRequest), ctx, req)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePeers", reflect.TypeOf((*MockSpace)(nil).GetNodePeers), arg0)
}
// HandleMessage mocks base method.
func (m *MockSpace) HandleMessage(ctx context.Context, msg *objectmessages.HeadUpdate) error {
func (m *MockSpace) HandleMessage(arg0 context.Context, arg1 *objectmessages.HeadUpdate) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleMessage", ctx, msg)
ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// HandleMessage indicates an expected call of HandleMessage.
func (mr *MockSpaceMockRecorder) HandleMessage(ctx, msg any) *gomock.Call {
func (mr *MockSpaceMockRecorder) HandleMessage(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockSpace)(nil).HandleMessage), ctx, msg)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockSpace)(nil).HandleMessage), arg0, arg1)
}
// HandleRangeRequest mocks base method.
func (m *MockSpace) HandleRangeRequest(ctx context.Context, req *spacesyncproto.HeadSyncRequest) (*spacesyncproto.HeadSyncResponse, error) {
func (m *MockSpace) HandleRangeRequest(arg0 context.Context, arg1 *spacesyncproto.HeadSyncRequest) (*spacesyncproto.HeadSyncResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleRangeRequest", ctx, req)
ret := m.ctrl.Call(m, "HandleRangeRequest", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.HeadSyncResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleRangeRequest indicates an expected call of HandleRangeRequest.
func (mr *MockSpaceMockRecorder) HandleRangeRequest(ctx, req any) *gomock.Call {
func (mr *MockSpaceMockRecorder) HandleRangeRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRangeRequest", reflect.TypeOf((*MockSpace)(nil).HandleRangeRequest), ctx, req)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRangeRequest", reflect.TypeOf((*MockSpace)(nil).HandleRangeRequest), arg0, arg1)
}
// HandleStreamSyncRequest mocks base method.
func (m *MockSpace) HandleStreamSyncRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage, stream drpc.Stream) error {
func (m *MockSpace) HandleStreamSyncRequest(arg0 context.Context, arg1 *spacesyncproto.ObjectSyncMessage, arg2 drpc.Stream) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleStreamSyncRequest", ctx, req, stream)
ret := m.ctrl.Call(m, "HandleStreamSyncRequest", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// HandleStreamSyncRequest indicates an expected call of HandleStreamSyncRequest.
func (mr *MockSpaceMockRecorder) HandleStreamSyncRequest(ctx, req, stream any) *gomock.Call {
func (mr *MockSpaceMockRecorder) HandleStreamSyncRequest(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamSyncRequest", reflect.TypeOf((*MockSpace)(nil).HandleStreamSyncRequest), ctx, req, stream)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamSyncRequest", reflect.TypeOf((*MockSpace)(nil).HandleStreamSyncRequest), arg0, arg1, arg2)
}
// Id mocks base method.
@ -226,17 +210,17 @@ func (mr *MockSpaceMockRecorder) Id() *gomock.Call {
}
// Init mocks base method.
func (m *MockSpace) Init(ctx context.Context) error {
func (m *MockSpace) Init(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", ctx)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockSpaceMockRecorder) Init(ctx any) *gomock.Call {
func (mr *MockSpaceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpace)(nil).Init), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpace)(nil).Init), arg0)
}
// Storage mocks base method.
@ -310,16 +294,16 @@ func (mr *MockSpaceMockRecorder) TreeSyncer() *gomock.Call {
}
// TryClose mocks base method.
func (m *MockSpace) TryClose(objectTTL time.Duration) (bool, error) {
func (m *MockSpace) TryClose(arg0 time.Duration) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TryClose", objectTTL)
ret := m.ctrl.Call(m, "TryClose", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TryClose indicates an expected call of TryClose.
func (mr *MockSpaceMockRecorder) TryClose(objectTTL any) *gomock.Call {
func (mr *MockSpaceMockRecorder) TryClose(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockSpace)(nil).TryClose), objectTTL)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockSpace)(nil).TryClose), arg0)
}

97
commonspace/object/acl/list/mock_list/mock_list.go
View file

@ -23,7 +23,6 @@ import (
type MockAclList struct {
ctrl *gomock.Controller
recorder *MockAclListMockRecorder
isgomock struct{}
}
// MockAclListMockRecorder is the mock recorder for MockAclList.
@ -58,89 +57,89 @@ func (mr *MockAclListMockRecorder) AclState() *gomock.Call {
}
// AddRawRecord mocks base method.
func (m *MockAclList) AddRawRecord(rawRec *consensusproto.RawRecordWithId) error {
func (m *MockAclList) AddRawRecord(arg0 *consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecord", rawRec)
ret := m.ctrl.Call(m, "AddRawRecord", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecord indicates an expected call of AddRawRecord.
func (mr *MockAclListMockRecorder) AddRawRecord(rawRec any) *gomock.Call {
func (mr *MockAclListMockRecorder) AddRawRecord(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockAclList)(nil).AddRawRecord), rawRec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockAclList)(nil).AddRawRecord), arg0)
}
// AddRawRecords mocks base method.
func (m *MockAclList) AddRawRecords(rawRecords []*consensusproto.RawRecordWithId) error {
func (m *MockAclList) AddRawRecords(arg0 []*consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecords", rawRecords)
ret := m.ctrl.Call(m, "AddRawRecords", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecords indicates an expected call of AddRawRecords.
func (mr *MockAclListMockRecorder) AddRawRecords(rawRecords any) *gomock.Call {
func (mr *MockAclListMockRecorder) AddRawRecords(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecords", reflect.TypeOf((*MockAclList)(nil).AddRawRecords), rawRecords)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecords", reflect.TypeOf((*MockAclList)(nil).AddRawRecords), arg0)
}
// Close mocks base method.
func (m *MockAclList) Close(ctx context.Context) error {
func (m *MockAclList) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockAclListMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockAclListMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAclList)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAclList)(nil).Close), arg0)
}
// Get mocks base method.
func (m *MockAclList) Get(id string) (*list.AclRecord, error) {
func (m *MockAclList) Get(arg0 string) (*list.AclRecord, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", id)
ret := m.ctrl.Call(m, "Get", arg0)
ret0, _ := ret[0].(*list.AclRecord)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Get indicates an expected call of Get.
func (mr *MockAclListMockRecorder) Get(id any) *gomock.Call {
func (mr *MockAclListMockRecorder) Get(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAclList)(nil).Get), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAclList)(nil).Get), arg0)
}
// GetIndex mocks base method.
func (m *MockAclList) GetIndex(idx int) (*list.AclRecord, error) {
func (m *MockAclList) GetIndex(arg0 int) (*list.AclRecord, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetIndex", idx)
ret := m.ctrl.Call(m, "GetIndex", arg0)
ret0, _ := ret[0].(*list.AclRecord)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetIndex indicates an expected call of GetIndex.
func (mr *MockAclListMockRecorder) GetIndex(idx any) *gomock.Call {
func (mr *MockAclListMockRecorder) GetIndex(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockAclList)(nil).GetIndex), idx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockAclList)(nil).GetIndex), arg0)
}
// HasHead mocks base method.
func (m *MockAclList) HasHead(head string) bool {
func (m *MockAclList) HasHead(arg0 string) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasHead", head)
ret := m.ctrl.Call(m, "HasHead", arg0)
ret0, _ := ret[0].(bool)
return ret0
}
// HasHead indicates an expected call of HasHead.
func (mr *MockAclListMockRecorder) HasHead(head any) *gomock.Call {
func (mr *MockAclListMockRecorder) HasHead(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHead", reflect.TypeOf((*MockAclList)(nil).HasHead), head)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHead", reflect.TypeOf((*MockAclList)(nil).HasHead), arg0)
}
// Head mocks base method.
@ -172,42 +171,42 @@ func (mr *MockAclListMockRecorder) Id() *gomock.Call {
}
// IsAfter mocks base method.
func (m *MockAclList) IsAfter(first, second string) (bool, error) {
func (m *MockAclList) IsAfter(arg0, arg1 string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsAfter", first, second)
ret := m.ctrl.Call(m, "IsAfter", arg0, arg1)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsAfter indicates an expected call of IsAfter.
func (mr *MockAclListMockRecorder) IsAfter(first, second any) *gomock.Call {
func (mr *MockAclListMockRecorder) IsAfter(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockAclList)(nil).IsAfter), first, second)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockAclList)(nil).IsAfter), arg0, arg1)
}
// Iterate mocks base method.
func (m *MockAclList) Iterate(iterFunc func(*list.AclRecord) bool) {
func (m *MockAclList) Iterate(arg0 func(*list.AclRecord) bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Iterate", iterFunc)
m.ctrl.Call(m, "Iterate", arg0)
}
// Iterate indicates an expected call of Iterate.
func (mr *MockAclListMockRecorder) Iterate(iterFunc any) *gomock.Call {
func (mr *MockAclListMockRecorder) Iterate(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockAclList)(nil).Iterate), iterFunc)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockAclList)(nil).Iterate), arg0)
}
// IterateFrom mocks base method.
func (m *MockAclList) IterateFrom(startId string, iterFunc func(*list.AclRecord) bool) {
func (m *MockAclList) IterateFrom(arg0 string, arg1 func(*list.AclRecord) bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "IterateFrom", startId, iterFunc)
m.ctrl.Call(m, "IterateFrom", arg0, arg1)
}
// IterateFrom indicates an expected call of IterateFrom.
func (mr *MockAclListMockRecorder) IterateFrom(startId, iterFunc any) *gomock.Call {
func (mr *MockAclListMockRecorder) IterateFrom(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockAclList)(nil).IterateFrom), startId, iterFunc)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockAclList)(nil).IterateFrom), arg0, arg1)
}
// KeyStorage mocks base method.
@ -289,33 +288,33 @@ func (mr *MockAclListMockRecorder) Records() *gomock.Call {
}
// RecordsAfter mocks base method.
func (m *MockAclList) RecordsAfter(ctx context.Context, id string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockAclList) RecordsAfter(arg0 context.Context, arg1 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecordsAfter", ctx, id)
ret := m.ctrl.Call(m, "RecordsAfter", arg0, arg1)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RecordsAfter indicates an expected call of RecordsAfter.
func (mr *MockAclListMockRecorder) RecordsAfter(ctx, id any) *gomock.Call {
func (mr *MockAclListMockRecorder) RecordsAfter(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockAclList)(nil).RecordsAfter), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockAclList)(nil).RecordsAfter), arg0, arg1)
}
// RecordsBefore mocks base method.
func (m *MockAclList) RecordsBefore(ctx context.Context, headId string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockAclList) RecordsBefore(arg0 context.Context, arg1 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecordsBefore", ctx, headId)
ret := m.ctrl.Call(m, "RecordsBefore", arg0, arg1)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RecordsBefore indicates an expected call of RecordsBefore.
func (mr *MockAclListMockRecorder) RecordsBefore(ctx, headId any) *gomock.Call {
func (mr *MockAclListMockRecorder) RecordsBefore(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsBefore", reflect.TypeOf((*MockAclList)(nil).RecordsBefore), ctx, headId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsBefore", reflect.TypeOf((*MockAclList)(nil).RecordsBefore), arg0, arg1)
}
// Root mocks base method.
@ -345,15 +344,15 @@ func (mr *MockAclListMockRecorder) Unlock() *gomock.Call {
}
// ValidateRawRecord mocks base method.
func (m *MockAclList) ValidateRawRecord(rawRec *consensusproto.RawRecord, afterValid func(*list.AclState) error) error {
func (m *MockAclList) ValidateRawRecord(arg0 *consensusproto.RawRecord, arg1 func(*list.AclState) error) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateRawRecord", rawRec, afterValid)
ret := m.ctrl.Call(m, "ValidateRawRecord", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// ValidateRawRecord indicates an expected call of ValidateRawRecord.
func (mr *MockAclListMockRecorder) ValidateRawRecord(rawRec, afterValid any) *gomock.Call {
func (mr *MockAclListMockRecorder) ValidateRawRecord(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockAclList)(nil).ValidateRawRecord), rawRec, afterValid)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockAclList)(nil).ValidateRawRecord), arg0, arg1)
}

222
commonspace/object/acl/syncacl/mock_syncacl/mock_syncacl.go
View file

@ -17,7 +17,6 @@ import (
list "github.com/anyproto/any-sync/commonspace/object/acl/list"
headupdater "github.com/anyproto/any-sync/commonspace/object/acl/syncacl/headupdater"
response "github.com/anyproto/any-sync/commonspace/object/acl/syncacl/response"
spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
objectmessages "github.com/anyproto/any-sync/commonspace/sync/objectsync/objectmessages"
syncdeps "github.com/anyproto/any-sync/commonspace/sync/syncdeps"
syncstatus "github.com/anyproto/any-sync/commonspace/syncstatus"
@ -33,7 +32,6 @@ import (
type MockSyncClient struct {
ctrl *gomock.Controller
recorder *MockSyncClientMockRecorder
isgomock struct{}
}
// MockSyncClientMockRecorder is the mock recorder for MockSyncClient.
@ -54,82 +52,81 @@ func (m *MockSyncClient) EXPECT() *MockSyncClientMockRecorder {
}
// Broadcast mocks base method.
func (m *MockSyncClient) Broadcast(ctx context.Context, headUpdate *objectmessages.HeadUpdate) error {
func (m *MockSyncClient) Broadcast(arg0 context.Context, arg1 *objectmessages.HeadUpdate) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Broadcast", ctx, headUpdate)
ret := m.ctrl.Call(m, "Broadcast", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Broadcast indicates an expected call of Broadcast.
func (mr *MockSyncClientMockRecorder) Broadcast(ctx, headUpdate any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) Broadcast(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), ctx, headUpdate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), arg0, arg1)
}
// CreateFullSyncRequest mocks base method.
func (m *MockSyncClient) CreateFullSyncRequest(peerId string, l list.AclList) *objectmessages.Request {
func (m *MockSyncClient) CreateFullSyncRequest(arg0 string, arg1 list.AclList) *objectmessages.Request {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateFullSyncRequest", peerId, l)
ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1)
ret0, _ := ret[0].(*objectmessages.Request)
return ret0
}
// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(peerId, l any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), peerId, l)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), arg0, arg1)
}
// CreateFullSyncResponse mocks base method.
func (m *MockSyncClient) CreateFullSyncResponse(l list.AclList, theirHead string) (*response.Response, error) {
func (m *MockSyncClient) CreateFullSyncResponse(arg0 list.AclList, arg1 string) (*response.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateFullSyncResponse", l, theirHead)
ret := m.ctrl.Call(m, "CreateFullSyncResponse", arg0, arg1)
ret0, _ := ret[0].(*response.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateFullSyncResponse indicates an expected call of CreateFullSyncResponse.
func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(l, theirHead any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncResponse), l, theirHead)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncResponse), arg0, arg1)
}
// CreateHeadUpdate mocks base method.
func (m *MockSyncClient) CreateHeadUpdate(l list.AclList, added []*consensusproto.RawRecordWithId) (*objectmessages.HeadUpdate, error) {
func (m *MockSyncClient) CreateHeadUpdate(arg0 list.AclList, arg1 []*consensusproto.RawRecordWithId) (*objectmessages.HeadUpdate, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateHeadUpdate", l, added)
ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1)
ret0, _ := ret[0].(*objectmessages.HeadUpdate)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(l, added any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), l, added)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), arg0, arg1)
}
// QueueRequest mocks base method.
func (m *MockSyncClient) QueueRequest(ctx context.Context, req syncdeps.Request) error {
func (m *MockSyncClient) QueueRequest(arg0 context.Context, arg1 syncdeps.Request) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "QueueRequest", ctx, req)
ret := m.ctrl.Call(m, "QueueRequest", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// QueueRequest indicates an expected call of QueueRequest.
func (mr *MockSyncClientMockRecorder) QueueRequest(ctx, req any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) QueueRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueRequest", reflect.TypeOf((*MockSyncClient)(nil).QueueRequest), ctx, req)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueRequest", reflect.TypeOf((*MockSyncClient)(nil).QueueRequest), arg0, arg1)
}
// MockSyncAcl is a mock of SyncAcl interface.
type MockSyncAcl struct {
ctrl *gomock.Controller
recorder *MockSyncAclMockRecorder
isgomock struct{}
}
// MockSyncAclMockRecorder is the mock recorder for MockSyncAcl.
@ -164,148 +161,133 @@ func (mr *MockSyncAclMockRecorder) AclState() *gomock.Call {
}
// AddRawRecord mocks base method.
func (m *MockSyncAcl) AddRawRecord(rawRec *consensusproto.RawRecordWithId) error {
func (m *MockSyncAcl) AddRawRecord(arg0 *consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecord", rawRec)
ret := m.ctrl.Call(m, "AddRawRecord", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecord indicates an expected call of AddRawRecord.
func (mr *MockSyncAclMockRecorder) AddRawRecord(rawRec any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) AddRawRecord(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecord), rawRec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecord), arg0)
}
// AddRawRecords mocks base method.
func (m *MockSyncAcl) AddRawRecords(rawRecords []*consensusproto.RawRecordWithId) error {
func (m *MockSyncAcl) AddRawRecords(arg0 []*consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecords", rawRecords)
ret := m.ctrl.Call(m, "AddRawRecords", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecords indicates an expected call of AddRawRecords.
func (mr *MockSyncAclMockRecorder) AddRawRecords(rawRecords any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) AddRawRecords(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecords", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecords), rawRecords)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecords", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecords), arg0)
}
// Close mocks base method.
func (m *MockSyncAcl) Close(ctx context.Context) error {
func (m *MockSyncAcl) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockSyncAclMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSyncAcl)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSyncAcl)(nil).Close), arg0)
}
// Get mocks base method.
func (m *MockSyncAcl) Get(id string) (*list.AclRecord, error) {
func (m *MockSyncAcl) Get(arg0 string) (*list.AclRecord, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", id)
ret := m.ctrl.Call(m, "Get", arg0)
ret0, _ := ret[0].(*list.AclRecord)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Get indicates an expected call of Get.
func (mr *MockSyncAclMockRecorder) Get(id any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) Get(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSyncAcl)(nil).Get), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSyncAcl)(nil).Get), arg0)
}
// GetIndex mocks base method.
func (m *MockSyncAcl) GetIndex(idx int) (*list.AclRecord, error) {
func (m *MockSyncAcl) GetIndex(arg0 int) (*list.AclRecord, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetIndex", idx)
ret := m.ctrl.Call(m, "GetIndex", arg0)
ret0, _ := ret[0].(*list.AclRecord)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetIndex indicates an expected call of GetIndex.
func (mr *MockSyncAclMockRecorder) GetIndex(idx any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) GetIndex(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockSyncAcl)(nil).GetIndex), idx)
}
// HandleDeprecatedRequest mocks base method.
func (m *MockSyncAcl) HandleDeprecatedRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleDeprecatedRequest", ctx, req)
ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleDeprecatedRequest indicates an expected call of HandleDeprecatedRequest.
func (mr *MockSyncAclMockRecorder) HandleDeprecatedRequest(ctx, req any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDeprecatedRequest", reflect.TypeOf((*MockSyncAcl)(nil).HandleDeprecatedRequest), ctx, req)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockSyncAcl)(nil).GetIndex), arg0)
}
// HandleHeadUpdate mocks base method.
func (m *MockSyncAcl) HandleHeadUpdate(ctx context.Context, statusUpdater syncstatus.StatusUpdater, headUpdate drpc.Message) (syncdeps.Request, error) {
func (m *MockSyncAcl) HandleHeadUpdate(arg0 context.Context, arg1 syncstatus.StatusUpdater, arg2 drpc.Message) (syncdeps.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleHeadUpdate", ctx, statusUpdater, headUpdate)
ret := m.ctrl.Call(m, "HandleHeadUpdate", arg0, arg1, arg2)
ret0, _ := ret[0].(syncdeps.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleHeadUpdate indicates an expected call of HandleHeadUpdate.
func (mr *MockSyncAclMockRecorder) HandleHeadUpdate(ctx, statusUpdater, headUpdate any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) HandleHeadUpdate(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockSyncAcl)(nil).HandleHeadUpdate), ctx, statusUpdater, headUpdate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockSyncAcl)(nil).HandleHeadUpdate), arg0, arg1, arg2)
}
// HandleResponse mocks base method.
func (m *MockSyncAcl) HandleResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
func (m *MockSyncAcl) HandleResponse(arg0 context.Context, arg1, arg2 string, arg3 syncdeps.Response) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleResponse", ctx, peerId, objectId, resp)
ret := m.ctrl.Call(m, "HandleResponse", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// HandleResponse indicates an expected call of HandleResponse.
func (mr *MockSyncAclMockRecorder) HandleResponse(ctx, peerId, objectId, resp any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) HandleResponse(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockSyncAcl)(nil).HandleResponse), ctx, peerId, objectId, resp)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockSyncAcl)(nil).HandleResponse), arg0, arg1, arg2, arg3)
}
// HandleStreamRequest mocks base method.
func (m *MockSyncAcl) HandleStreamRequest(ctx context.Context, rq syncdeps.Request, updater syncdeps.QueueSizeUpdater, send func(proto.Message) error) (syncdeps.Request, error) {
func (m *MockSyncAcl) HandleStreamRequest(arg0 context.Context, arg1 syncdeps.Request, arg2 syncdeps.QueueSizeUpdater, arg3 func(proto.Message) error) (syncdeps.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleStreamRequest", ctx, rq, updater, send)
ret := m.ctrl.Call(m, "HandleStreamRequest", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(syncdeps.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleStreamRequest indicates an expected call of HandleStreamRequest.
func (mr *MockSyncAclMockRecorder) HandleStreamRequest(ctx, rq, updater, send any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) HandleStreamRequest(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockSyncAcl)(nil).HandleStreamRequest), ctx, rq, updater, send)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockSyncAcl)(nil).HandleStreamRequest), arg0, arg1, arg2, arg3)
}
// HasHead mocks base method.
func (m *MockSyncAcl) HasHead(head string) bool {
func (m *MockSyncAcl) HasHead(arg0 string) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasHead", head)
ret := m.ctrl.Call(m, "HasHead", arg0)
ret0, _ := ret[0].(bool)
return ret0
}
// HasHead indicates an expected call of HasHead.
func (mr *MockSyncAclMockRecorder) HasHead(head any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) HasHead(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHead", reflect.TypeOf((*MockSyncAcl)(nil).HasHead), head)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHead", reflect.TypeOf((*MockSyncAcl)(nil).HasHead), arg0)
}
// Head mocks base method.
@ -337,56 +319,56 @@ func (mr *MockSyncAclMockRecorder) Id() *gomock.Call {
}
// Init mocks base method.
func (m *MockSyncAcl) Init(a *app.App) error {
func (m *MockSyncAcl) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockSyncAclMockRecorder) Init(a any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSyncAcl)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSyncAcl)(nil).Init), arg0)
}
// IsAfter mocks base method.
func (m *MockSyncAcl) IsAfter(first, second string) (bool, error) {
func (m *MockSyncAcl) IsAfter(arg0, arg1 string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsAfter", first, second)
ret := m.ctrl.Call(m, "IsAfter", arg0, arg1)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsAfter indicates an expected call of IsAfter.
func (mr *MockSyncAclMockRecorder) IsAfter(first, second any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) IsAfter(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockSyncAcl)(nil).IsAfter), first, second)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockSyncAcl)(nil).IsAfter), arg0, arg1)
}
// Iterate mocks base method.
func (m *MockSyncAcl) Iterate(iterFunc func(*list.AclRecord) bool) {
func (m *MockSyncAcl) Iterate(arg0 func(*list.AclRecord) bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Iterate", iterFunc)
m.ctrl.Call(m, "Iterate", arg0)
}
// Iterate indicates an expected call of Iterate.
func (mr *MockSyncAclMockRecorder) Iterate(iterFunc any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) Iterate(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockSyncAcl)(nil).Iterate), iterFunc)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockSyncAcl)(nil).Iterate), arg0)
}
// IterateFrom mocks base method.
func (m *MockSyncAcl) IterateFrom(startId string, iterFunc func(*list.AclRecord) bool) {
func (m *MockSyncAcl) IterateFrom(arg0 string, arg1 func(*list.AclRecord) bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "IterateFrom", startId, iterFunc)
m.ctrl.Call(m, "IterateFrom", arg0, arg1)
}
// IterateFrom indicates an expected call of IterateFrom.
func (mr *MockSyncAclMockRecorder) IterateFrom(startId, iterFunc any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) IterateFrom(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncAcl)(nil).IterateFrom), startId, iterFunc)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncAcl)(nil).IterateFrom), arg0, arg1)
}
// KeyStorage mocks base method.
@ -482,33 +464,33 @@ func (mr *MockSyncAclMockRecorder) Records() *gomock.Call {
}
// RecordsAfter mocks base method.
func (m *MockSyncAcl) RecordsAfter(ctx context.Context, id string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockSyncAcl) RecordsAfter(arg0 context.Context, arg1 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecordsAfter", ctx, id)
ret := m.ctrl.Call(m, "RecordsAfter", arg0, arg1)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RecordsAfter indicates an expected call of RecordsAfter.
func (mr *MockSyncAclMockRecorder) RecordsAfter(ctx, id any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) RecordsAfter(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockSyncAcl)(nil).RecordsAfter), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockSyncAcl)(nil).RecordsAfter), arg0, arg1)
}
// RecordsBefore mocks base method.
func (m *MockSyncAcl) RecordsBefore(ctx context.Context, headId string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockSyncAcl) RecordsBefore(arg0 context.Context, arg1 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecordsBefore", ctx, headId)
ret := m.ctrl.Call(m, "RecordsBefore", arg0, arg1)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RecordsBefore indicates an expected call of RecordsBefore.
func (mr *MockSyncAclMockRecorder) RecordsBefore(ctx, headId any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) RecordsBefore(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsBefore", reflect.TypeOf((*MockSyncAcl)(nil).RecordsBefore), ctx, headId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsBefore", reflect.TypeOf((*MockSyncAcl)(nil).RecordsBefore), arg0, arg1)
}
// ResponseCollector mocks base method.
@ -540,55 +522,43 @@ func (mr *MockSyncAclMockRecorder) Root() *gomock.Call {
}
// Run mocks base method.
func (m *MockSyncAcl) Run(ctx context.Context) error {
func (m *MockSyncAcl) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockSyncAclMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSyncAcl)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSyncAcl)(nil).Run), arg0)
}
// SetAclUpdater mocks base method.
func (m *MockSyncAcl) SetAclUpdater(updater headupdater.AclUpdater) {
func (m *MockSyncAcl) SetAclUpdater(arg0 headupdater.AclUpdater) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetAclUpdater", updater)
m.ctrl.Call(m, "SetAclUpdater", arg0)
}
// SetAclUpdater indicates an expected call of SetAclUpdater.
func (mr *MockSyncAclMockRecorder) SetAclUpdater(updater any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) SetAclUpdater(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAclUpdater", reflect.TypeOf((*MockSyncAcl)(nil).SetAclUpdater), updater)
}
// SetHeadUpdater mocks base method.
func (m *MockSyncAcl) SetHeadUpdater(updater headupdater.HeadUpdater) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetHeadUpdater", updater)
}
// SetHeadUpdater indicates an expected call of SetHeadUpdater.
func (mr *MockSyncAclMockRecorder) SetHeadUpdater(updater any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeadUpdater", reflect.TypeOf((*MockSyncAcl)(nil).SetHeadUpdater), updater)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAclUpdater", reflect.TypeOf((*MockSyncAcl)(nil).SetAclUpdater), arg0)
}
// SyncWithPeer mocks base method.
func (m *MockSyncAcl) SyncWithPeer(ctx context.Context, p peer.Peer) error {
func (m *MockSyncAcl) SyncWithPeer(arg0 context.Context, arg1 peer.Peer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SyncWithPeer", ctx, p)
ret := m.ctrl.Call(m, "SyncWithPeer", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// SyncWithPeer indicates an expected call of SyncWithPeer.
func (mr *MockSyncAclMockRecorder) SyncWithPeer(ctx, p any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) SyncWithPeer(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncAcl)(nil).SyncWithPeer), ctx, p)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncAcl)(nil).SyncWithPeer), arg0, arg1)
}
// Unlock mocks base method.
@ -604,15 +574,15 @@ func (mr *MockSyncAclMockRecorder) Unlock() *gomock.Call {
}
// ValidateRawRecord mocks base method.
func (m *MockSyncAcl) ValidateRawRecord(rawRec *consensusproto.RawRecord, afterValid func(*list.AclState) error) error {
func (m *MockSyncAcl) ValidateRawRecord(arg0 *consensusproto.RawRecord, arg1 func(*list.AclState) error) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateRawRecord", rawRec, afterValid)
ret := m.ctrl.Call(m, "ValidateRawRecord", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// ValidateRawRecord indicates an expected call of ValidateRawRecord.
func (mr *MockSyncAclMockRecorder) ValidateRawRecord(rawRec, afterValid any) *gomock.Call {
func (mr *MockSyncAclMockRecorder) ValidateRawRecord(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).ValidateRawRecord), rawRec, afterValid)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).ValidateRawRecord), arg0, arg1)
}

64
commonspace/object/acl/syncacl/syncaclhandler_test.go
View file

@ -12,7 +12,6 @@ import (
"github.com/anyproto/any-sync/commonspace/object/acl/list/mock_list"
"github.com/anyproto/any-sync/commonspace/object/acl/syncacl/mock_syncacl"
"github.com/anyproto/any-sync/commonspace/object/acl/syncacl/response"
"github.com/anyproto/any-sync/commonspace/spacesyncproto"
"github.com/anyproto/any-sync/commonspace/sync/objectsync/objectmessages"
"github.com/anyproto/any-sync/commonspace/syncstatus/mock_syncstatus"
"github.com/anyproto/any-sync/consensus/consensusproto"
@ -184,69 +183,6 @@ func TestSyncAclHandler_HandleStreamRequest(t *testing.T) {
})
}
func TestSyncAclHandler_HandleDeprecatedRequest(t *testing.T) {
t.Run("handle deprecated request, records, return empty response", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.stop()
chWithId := &consensusproto.RawRecordWithId{}
fullRequest := &consensusproto.LogFullSyncRequest{
Head: "h1",
Records: []*consensusproto.RawRecordWithId{chWithId},
}
logMessage := consensusproto.WrapFullRequest(fullRequest, chWithId)
objectMsg, err := spacesyncproto.MarshallSyncMessage(logMessage, "spaceId", "objectId")
require.NoError(t, err)
fx.aclMock.EXPECT().Root().Return(chWithId)
fx.aclMock.EXPECT().Head().Return(&list.AclRecord{Id: "h2"})
fx.aclMock.EXPECT().HasHead("h1").Return(false)
fx.aclMock.EXPECT().AddRawRecords([]*consensusproto.RawRecordWithId{chWithId}).Return(nil)
resp, err := fx.syncHandler.HandleDeprecatedRequest(ctx, objectMsg)
require.NoError(t, err)
require.NotNil(t, resp)
require.Equal(t, "spaceId", resp.SpaceId)
require.Equal(t, "objectId", resp.ObjectId)
})
t.Run("handle deprecated request, no records, return empty response", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.stop()
chWithId := &consensusproto.RawRecordWithId{}
fullRequest := &consensusproto.LogFullSyncRequest{
Head: "h1",
}
logMessage := consensusproto.WrapFullRequest(fullRequest, chWithId)
objectMsg, err := spacesyncproto.MarshallSyncMessage(logMessage, "spaceId", "objectId")
require.NoError(t, err)
fx.aclMock.EXPECT().Root().Return(chWithId)
fx.aclMock.EXPECT().Head().Return(&list.AclRecord{Id: "h2"})
fx.aclMock.EXPECT().HasHead("h1").Return(false)
resp, err := fx.syncHandler.HandleDeprecatedRequest(ctx, objectMsg)
require.NoError(t, err)
require.NotNil(t, resp)
require.Equal(t, "spaceId", resp.SpaceId)
require.Equal(t, "objectId", resp.ObjectId)
})
t.Run("handle deprecated request, has head, return records after", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.stop()
chWithId := &consensusproto.RawRecordWithId{}
fullRequest := &consensusproto.LogFullSyncRequest{
Head: "h1",
}
logMessage := consensusproto.WrapFullRequest(fullRequest, chWithId)
objectMsg, err := spacesyncproto.MarshallSyncMessage(logMessage, "spaceId", "objectId")
require.NoError(t, err)
fx.aclMock.EXPECT().Root().Return(chWithId)
fx.aclMock.EXPECT().Head().Times(2).Return(&list.AclRecord{Id: "h2"})
fx.aclMock.EXPECT().HasHead("h1").Return(true)
fx.aclMock.EXPECT().RecordsAfter(ctx, "h1").Return([]*consensusproto.RawRecordWithId{chWithId}, nil)
resp, err := fx.syncHandler.HandleDeprecatedRequest(ctx, objectMsg)
require.NoError(t, err)
require.NotNil(t, resp)
require.Equal(t, "spaceId", resp.SpaceId)
require.Equal(t, "objectId", resp.ObjectId)
})
}
func TestSyncAclHandler_HandleResponse(t *testing.T) {
t.Run("handle response, no changes, return nil", func(t *testing.T) {
fx := newSyncHandlerFixture(t)

117
commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
View file

@ -17,7 +17,6 @@ import (
list "github.com/anyproto/any-sync/commonspace/object/acl/list"
objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
gomock "go.uber.org/mock/gomock"
)
@ -25,7 +24,6 @@ import (
type MockObjectTree struct {
ctrl *gomock.Controller
recorder *MockObjectTreeMockRecorder
isgomock struct{}
}
// MockObjectTreeMockRecorder is the mock recorder for MockObjectTree.
@ -60,63 +58,63 @@ func (mr *MockObjectTreeMockRecorder) AclList() *gomock.Call {
}
// AddContent mocks base method.
func (m *MockObjectTree) AddContent(ctx context.Context, content objecttree.SignableChangeContent) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContent", ctx, content)
ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddContent indicates an expected call of AddContent.
func (mr *MockObjectTreeMockRecorder) AddContent(ctx, content any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddContent(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockObjectTree)(nil).AddContent), ctx, content)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockObjectTree)(nil).AddContent), arg0, arg1)
}
// AddContentWithValidator mocks base method.
func (m *MockObjectTree) AddContentWithValidator(ctx context.Context, content objecttree.SignableChangeContent, validate func(*treechangeproto.RawTreeChangeWithId) error) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddContentWithValidator(arg0 context.Context, arg1 objecttree.SignableChangeContent, arg2 func(objecttree.StorageChange) error) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContentWithValidator", ctx, content, validate)
ret := m.ctrl.Call(m, "AddContentWithValidator", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddContentWithValidator indicates an expected call of AddContentWithValidator.
func (mr *MockObjectTreeMockRecorder) AddContentWithValidator(ctx, content, validate any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddContentWithValidator(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContentWithValidator", reflect.TypeOf((*MockObjectTree)(nil).AddContentWithValidator), ctx, content, validate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContentWithValidator", reflect.TypeOf((*MockObjectTree)(nil).AddContentWithValidator), arg0, arg1, arg2)
}
// AddRawChanges mocks base method.
func (m *MockObjectTree) AddRawChanges(ctx context.Context, changes objecttree.RawChangesPayload) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChanges", ctx, changes)
ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChanges indicates an expected call of AddRawChanges.
func (mr *MockObjectTreeMockRecorder) AddRawChanges(ctx, changes any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddRawChanges(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockObjectTree)(nil).AddRawChanges), ctx, changes)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockObjectTree)(nil).AddRawChanges), arg0, arg1)
}
// AddRawChangesWithUpdater mocks base method.
func (m *MockObjectTree) AddRawChangesWithUpdater(ctx context.Context, changes objecttree.RawChangesPayload, updater func(objecttree.ObjectTree, objecttree.Mode) error) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddRawChangesWithUpdater(arg0 context.Context, arg1 objecttree.RawChangesPayload, arg2 func(objecttree.ObjectTree, objecttree.Mode) error) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChangesWithUpdater", ctx, changes, updater)
ret := m.ctrl.Call(m, "AddRawChangesWithUpdater", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChangesWithUpdater indicates an expected call of AddRawChangesWithUpdater.
func (mr *MockObjectTreeMockRecorder) AddRawChangesWithUpdater(ctx, changes, updater any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddRawChangesWithUpdater(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesWithUpdater", reflect.TypeOf((*MockObjectTree)(nil).AddRawChangesWithUpdater), ctx, changes, updater)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesWithUpdater", reflect.TypeOf((*MockObjectTree)(nil).AddRawChangesWithUpdater), arg0, arg1, arg2)
}
// ChangeInfo mocks base method.
@ -133,34 +131,19 @@ func (mr *MockObjectTreeMockRecorder) ChangeInfo() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeInfo", reflect.TypeOf((*MockObjectTree)(nil).ChangeInfo))
}
// ChangesAfterCommonSnapshot mocks base method.
func (m *MockObjectTree) ChangesAfterCommonSnapshot(snapshotPath, heads []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshot", snapshotPath, heads)
ret0, _ := ret[0].([]*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChangesAfterCommonSnapshot indicates an expected call of ChangesAfterCommonSnapshot.
func (mr *MockObjectTreeMockRecorder) ChangesAfterCommonSnapshot(snapshotPath, heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshot", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshot), snapshotPath, heads)
}
// ChangesAfterCommonSnapshotLoader mocks base method.
func (m *MockObjectTree) ChangesAfterCommonSnapshotLoader(snapshotPath, heads []string) (objecttree.LoadIterator, error) {
func (m *MockObjectTree) ChangesAfterCommonSnapshotLoader(arg0, arg1 []string) (objecttree.LoadIterator, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshotLoader", snapshotPath, heads)
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshotLoader", arg0, arg1)
ret0, _ := ret[0].(objecttree.LoadIterator)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChangesAfterCommonSnapshotLoader indicates an expected call of ChangesAfterCommonSnapshotLoader.
func (mr *MockObjectTreeMockRecorder) ChangesAfterCommonSnapshotLoader(snapshotPath, heads any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) ChangesAfterCommonSnapshotLoader(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshotLoader", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshotLoader), snapshotPath, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshotLoader", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshotLoader), arg0, arg1)
}
// Close mocks base method.
@ -178,18 +161,18 @@ func (mr *MockObjectTreeMockRecorder) Close() *gomock.Call {
}
// Debug mocks base method.
func (m *MockObjectTree) Debug(parser objecttree.DescriptionParser) (objecttree.DebugInfo, error) {
func (m *MockObjectTree) Debug(arg0 objecttree.DescriptionParser) (objecttree.DebugInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Debug", parser)
ret := m.ctrl.Call(m, "Debug", arg0)
ret0, _ := ret[0].(objecttree.DebugInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Debug indicates an expected call of Debug.
func (mr *MockObjectTreeMockRecorder) Debug(parser any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) Debug(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockObjectTree)(nil).Debug), parser)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockObjectTree)(nil).Debug), arg0)
}
// Delete mocks base method.
@ -296,31 +279,31 @@ func (mr *MockObjectTreeMockRecorder) IsDerived() *gomock.Call {
}
// IterateFrom mocks base method.
func (m *MockObjectTree) IterateFrom(id string, convert func(*objecttree.Change, []byte) (any, error), iterate func(*objecttree.Change) bool) error {
func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func(*objecttree.Change, []byte) (any, error), arg2 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateFrom", id, convert, iterate)
ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// IterateFrom indicates an expected call of IterateFrom.
func (mr *MockObjectTreeMockRecorder) IterateFrom(id, convert, iterate any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) IterateFrom(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockObjectTree)(nil).IterateFrom), id, convert, iterate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockObjectTree)(nil).IterateFrom), arg0, arg1, arg2)
}
// IterateRoot mocks base method.
func (m *MockObjectTree) IterateRoot(convert func(*objecttree.Change, []byte) (any, error), iterate func(*objecttree.Change) bool) error {
func (m *MockObjectTree) IterateRoot(arg0 func(*objecttree.Change, []byte) (any, error), arg1 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateRoot", convert, iterate)
ret := m.ctrl.Call(m, "IterateRoot", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// IterateRoot indicates an expected call of IterateRoot.
func (mr *MockObjectTreeMockRecorder) IterateRoot(convert, iterate any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) IterateRoot(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockObjectTree)(nil).IterateRoot), convert, iterate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockObjectTree)(nil).IterateRoot), arg0, arg1)
}
// Len mocks base method.
@ -350,18 +333,18 @@ func (mr *MockObjectTreeMockRecorder) Lock() *gomock.Call {
}
// PrepareChange mocks base method.
func (m *MockObjectTree) PrepareChange(content objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockObjectTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PrepareChange", content)
ret := m.ctrl.Call(m, "PrepareChange", arg0)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PrepareChange indicates an expected call of PrepareChange.
func (mr *MockObjectTreeMockRecorder) PrepareChange(content any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) PrepareChange(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockObjectTree)(nil).PrepareChange), content)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockObjectTree)(nil).PrepareChange), arg0)
}
// Root mocks base method.
@ -379,15 +362,15 @@ func (mr *MockObjectTreeMockRecorder) Root() *gomock.Call {
}
// SetFlusher mocks base method.
func (m *MockObjectTree) SetFlusher(flusher objecttree.Flusher) {
func (m *MockObjectTree) SetFlusher(arg0 objecttree.Flusher) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetFlusher", flusher)
m.ctrl.Call(m, "SetFlusher", arg0)
}
// SetFlusher indicates an expected call of SetFlusher.
func (mr *MockObjectTreeMockRecorder) SetFlusher(flusher any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) SetFlusher(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlusher", reflect.TypeOf((*MockObjectTree)(nil).SetFlusher), flusher)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlusher", reflect.TypeOf((*MockObjectTree)(nil).SetFlusher), arg0)
}
// SnapshotPath mocks base method.
@ -405,10 +388,10 @@ func (mr *MockObjectTreeMockRecorder) SnapshotPath() *gomock.Call {
}
// Storage mocks base method.
func (m *MockObjectTree) Storage() treestorage.TreeStorage {
func (m *MockObjectTree) Storage() objecttree.Storage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Storage")
ret0, _ := ret[0].(treestorage.TreeStorage)
ret0, _ := ret[0].(objecttree.Storage)
return ret0
}
@ -419,18 +402,18 @@ func (mr *MockObjectTreeMockRecorder) Storage() *gomock.Call {
}
// TryClose mocks base method.
func (m *MockObjectTree) TryClose(objectTTL time.Duration) (bool, error) {
func (m *MockObjectTree) TryClose(arg0 time.Duration) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TryClose", objectTTL)
ret := m.ctrl.Call(m, "TryClose", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TryClose indicates an expected call of TryClose.
func (mr *MockObjectTreeMockRecorder) TryClose(objectTTL any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) TryClose(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockObjectTree)(nil).TryClose), objectTTL)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockObjectTree)(nil).TryClose), arg0)
}
// TryLock mocks base method.
@ -474,16 +457,16 @@ func (mr *MockObjectTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
}
// UnpackChange mocks base method.
func (m *MockObjectTree) UnpackChange(raw *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
func (m *MockObjectTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UnpackChange", raw)
ret := m.ctrl.Call(m, "UnpackChange", arg0)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UnpackChange indicates an expected call of UnpackChange.
func (mr *MockObjectTreeMockRecorder) UnpackChange(raw any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) UnpackChange(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockObjectTree)(nil).UnpackChange), raw)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockObjectTree)(nil).UnpackChange), arg0)
}

280
commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
View file

@ -19,8 +19,6 @@ import (
response "github.com/anyproto/any-sync/commonspace/object/tree/synctree/response"
updatelistener "github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener"
treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
objectmessages "github.com/anyproto/any-sync/commonspace/sync/objectsync/objectmessages"
syncdeps "github.com/anyproto/any-sync/commonspace/sync/syncdeps"
syncstatus "github.com/anyproto/any-sync/commonspace/syncstatus"
@ -34,7 +32,6 @@ import (
type MockSyncTree struct {
ctrl *gomock.Controller
recorder *MockSyncTreeMockRecorder
isgomock struct{}
}
// MockSyncTreeMockRecorder is the mock recorder for MockSyncTree.
@ -69,78 +66,78 @@ func (mr *MockSyncTreeMockRecorder) AclList() *gomock.Call {
}
// AddContent mocks base method.
func (m *MockSyncTree) AddContent(ctx context.Context, content objecttree.SignableChangeContent) (objecttree.AddResult, error) {
func (m *MockSyncTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContent", ctx, content)
ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddContent indicates an expected call of AddContent.
func (mr *MockSyncTreeMockRecorder) AddContent(ctx, content any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) AddContent(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockSyncTree)(nil).AddContent), ctx, content)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockSyncTree)(nil).AddContent), arg0, arg1)
}
// AddContentWithValidator mocks base method.
func (m *MockSyncTree) AddContentWithValidator(ctx context.Context, content objecttree.SignableChangeContent, validate func(*treechangeproto.RawTreeChangeWithId) error) (objecttree.AddResult, error) {
func (m *MockSyncTree) AddContentWithValidator(arg0 context.Context, arg1 objecttree.SignableChangeContent, arg2 func(objecttree.StorageChange) error) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContentWithValidator", ctx, content, validate)
ret := m.ctrl.Call(m, "AddContentWithValidator", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddContentWithValidator indicates an expected call of AddContentWithValidator.
func (mr *MockSyncTreeMockRecorder) AddContentWithValidator(ctx, content, validate any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) AddContentWithValidator(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContentWithValidator", reflect.TypeOf((*MockSyncTree)(nil).AddContentWithValidator), ctx, content, validate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContentWithValidator", reflect.TypeOf((*MockSyncTree)(nil).AddContentWithValidator), arg0, arg1, arg2)
}
// AddRawChanges mocks base method.
func (m *MockSyncTree) AddRawChanges(ctx context.Context, changes objecttree.RawChangesPayload) (objecttree.AddResult, error) {
func (m *MockSyncTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChanges", ctx, changes)
ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChanges indicates an expected call of AddRawChanges.
func (mr *MockSyncTreeMockRecorder) AddRawChanges(ctx, changes any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) AddRawChanges(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockSyncTree)(nil).AddRawChanges), ctx, changes)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockSyncTree)(nil).AddRawChanges), arg0, arg1)
}
// AddRawChangesFromPeer mocks base method.
func (m *MockSyncTree) AddRawChangesFromPeer(ctx context.Context, peerId string, changesPayload objecttree.RawChangesPayload) (objecttree.AddResult, error) {
func (m *MockSyncTree) AddRawChangesFromPeer(arg0 context.Context, arg1 string, arg2 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChangesFromPeer", ctx, peerId, changesPayload)
ret := m.ctrl.Call(m, "AddRawChangesFromPeer", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChangesFromPeer indicates an expected call of AddRawChangesFromPeer.
func (mr *MockSyncTreeMockRecorder) AddRawChangesFromPeer(ctx, peerId, changesPayload any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) AddRawChangesFromPeer(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesFromPeer", reflect.TypeOf((*MockSyncTree)(nil).AddRawChangesFromPeer), ctx, peerId, changesPayload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesFromPeer", reflect.TypeOf((*MockSyncTree)(nil).AddRawChangesFromPeer), arg0, arg1, arg2)
}
// AddRawChangesWithUpdater mocks base method.
func (m *MockSyncTree) AddRawChangesWithUpdater(ctx context.Context, changes objecttree.RawChangesPayload, updater func(objecttree.ObjectTree, objecttree.Mode) error) (objecttree.AddResult, error) {
func (m *MockSyncTree) AddRawChangesWithUpdater(arg0 context.Context, arg1 objecttree.RawChangesPayload, arg2 func(objecttree.ObjectTree, objecttree.Mode) error) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChangesWithUpdater", ctx, changes, updater)
ret := m.ctrl.Call(m, "AddRawChangesWithUpdater", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChangesWithUpdater indicates an expected call of AddRawChangesWithUpdater.
func (mr *MockSyncTreeMockRecorder) AddRawChangesWithUpdater(ctx, changes, updater any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) AddRawChangesWithUpdater(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesWithUpdater", reflect.TypeOf((*MockSyncTree)(nil).AddRawChangesWithUpdater), ctx, changes, updater)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesWithUpdater", reflect.TypeOf((*MockSyncTree)(nil).AddRawChangesWithUpdater), arg0, arg1, arg2)
}
// ChangeInfo mocks base method.
@ -157,34 +154,19 @@ func (mr *MockSyncTreeMockRecorder) ChangeInfo() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeInfo", reflect.TypeOf((*MockSyncTree)(nil).ChangeInfo))
}
// ChangesAfterCommonSnapshot mocks base method.
func (m *MockSyncTree) ChangesAfterCommonSnapshot(snapshotPath, heads []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshot", snapshotPath, heads)
ret0, _ := ret[0].([]*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChangesAfterCommonSnapshot indicates an expected call of ChangesAfterCommonSnapshot.
func (mr *MockSyncTreeMockRecorder) ChangesAfterCommonSnapshot(snapshotPath, heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshot", reflect.TypeOf((*MockSyncTree)(nil).ChangesAfterCommonSnapshot), snapshotPath, heads)
}
// ChangesAfterCommonSnapshotLoader mocks base method.
func (m *MockSyncTree) ChangesAfterCommonSnapshotLoader(snapshotPath, heads []string) (objecttree.LoadIterator, error) {
func (m *MockSyncTree) ChangesAfterCommonSnapshotLoader(arg0, arg1 []string) (objecttree.LoadIterator, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshotLoader", snapshotPath, heads)
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshotLoader", arg0, arg1)
ret0, _ := ret[0].(objecttree.LoadIterator)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChangesAfterCommonSnapshotLoader indicates an expected call of ChangesAfterCommonSnapshotLoader.
func (mr *MockSyncTreeMockRecorder) ChangesAfterCommonSnapshotLoader(snapshotPath, heads any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) ChangesAfterCommonSnapshotLoader(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshotLoader", reflect.TypeOf((*MockSyncTree)(nil).ChangesAfterCommonSnapshotLoader), snapshotPath, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshotLoader", reflect.TypeOf((*MockSyncTree)(nil).ChangesAfterCommonSnapshotLoader), arg0, arg1)
}
// Close mocks base method.
@ -202,18 +184,18 @@ func (mr *MockSyncTreeMockRecorder) Close() *gomock.Call {
}
// Debug mocks base method.
func (m *MockSyncTree) Debug(parser objecttree.DescriptionParser) (objecttree.DebugInfo, error) {
func (m *MockSyncTree) Debug(arg0 objecttree.DescriptionParser) (objecttree.DebugInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Debug", parser)
ret := m.ctrl.Call(m, "Debug", arg0)
ret0, _ := ret[0].(objecttree.DebugInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Debug indicates an expected call of Debug.
func (mr *MockSyncTreeMockRecorder) Debug(parser any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) Debug(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockSyncTree)(nil).Debug), parser)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockSyncTree)(nil).Debug), arg0)
}
// Delete mocks base method.
@ -245,63 +227,48 @@ func (mr *MockSyncTreeMockRecorder) GetChange(arg0 any) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChange", reflect.TypeOf((*MockSyncTree)(nil).GetChange), arg0)
}
// HandleDeprecatedRequest mocks base method.
func (m *MockSyncTree) HandleDeprecatedRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleDeprecatedRequest", ctx, req)
ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleDeprecatedRequest indicates an expected call of HandleDeprecatedRequest.
func (mr *MockSyncTreeMockRecorder) HandleDeprecatedRequest(ctx, req any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDeprecatedRequest", reflect.TypeOf((*MockSyncTree)(nil).HandleDeprecatedRequest), ctx, req)
}
// HandleHeadUpdate mocks base method.
func (m *MockSyncTree) HandleHeadUpdate(ctx context.Context, statusUpdater syncstatus.StatusUpdater, headUpdate drpc.Message) (syncdeps.Request, error) {
func (m *MockSyncTree) HandleHeadUpdate(arg0 context.Context, arg1 syncstatus.StatusUpdater, arg2 drpc.Message) (syncdeps.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleHeadUpdate", ctx, statusUpdater, headUpdate)
ret := m.ctrl.Call(m, "HandleHeadUpdate", arg0, arg1, arg2)
ret0, _ := ret[0].(syncdeps.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleHeadUpdate indicates an expected call of HandleHeadUpdate.
func (mr *MockSyncTreeMockRecorder) HandleHeadUpdate(ctx, statusUpdater, headUpdate any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) HandleHeadUpdate(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockSyncTree)(nil).HandleHeadUpdate), ctx, statusUpdater, headUpdate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockSyncTree)(nil).HandleHeadUpdate), arg0, arg1, arg2)
}
// HandleResponse mocks base method.
func (m *MockSyncTree) HandleResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
func (m *MockSyncTree) HandleResponse(arg0 context.Context, arg1, arg2 string, arg3 syncdeps.Response) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleResponse", ctx, peerId, objectId, resp)
ret := m.ctrl.Call(m, "HandleResponse", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// HandleResponse indicates an expected call of HandleResponse.
func (mr *MockSyncTreeMockRecorder) HandleResponse(ctx, peerId, objectId, resp any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) HandleResponse(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockSyncTree)(nil).HandleResponse), ctx, peerId, objectId, resp)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockSyncTree)(nil).HandleResponse), arg0, arg1, arg2, arg3)
}
// HandleStreamRequest mocks base method.
func (m *MockSyncTree) HandleStreamRequest(ctx context.Context, rq syncdeps.Request, updater syncdeps.QueueSizeUpdater, send func(proto.Message) error) (syncdeps.Request, error) {
func (m *MockSyncTree) HandleStreamRequest(arg0 context.Context, arg1 syncdeps.Request, arg2 syncdeps.QueueSizeUpdater, arg3 func(proto.Message) error) (syncdeps.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleStreamRequest", ctx, rq, updater, send)
ret := m.ctrl.Call(m, "HandleStreamRequest", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(syncdeps.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleStreamRequest indicates an expected call of HandleStreamRequest.
func (mr *MockSyncTreeMockRecorder) HandleStreamRequest(ctx, rq, updater, send any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) HandleStreamRequest(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockSyncTree)(nil).HandleStreamRequest), ctx, rq, updater, send)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockSyncTree)(nil).HandleStreamRequest), arg0, arg1, arg2, arg3)
}
// HasChanges mocks base method.
@ -379,31 +346,31 @@ func (mr *MockSyncTreeMockRecorder) IsDerived() *gomock.Call {
}
// IterateFrom mocks base method.
func (m *MockSyncTree) IterateFrom(id string, convert func(*objecttree.Change, []byte) (any, error), iterate func(*objecttree.Change) bool) error {
func (m *MockSyncTree) IterateFrom(arg0 string, arg1 func(*objecttree.Change, []byte) (any, error), arg2 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateFrom", id, convert, iterate)
ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// IterateFrom indicates an expected call of IterateFrom.
func (mr *MockSyncTreeMockRecorder) IterateFrom(id, convert, iterate any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) IterateFrom(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncTree)(nil).IterateFrom), id, convert, iterate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncTree)(nil).IterateFrom), arg0, arg1, arg2)
}
// IterateRoot mocks base method.
func (m *MockSyncTree) IterateRoot(convert func(*objecttree.Change, []byte) (any, error), iterate func(*objecttree.Change) bool) error {
func (m *MockSyncTree) IterateRoot(arg0 func(*objecttree.Change, []byte) (any, error), arg1 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateRoot", convert, iterate)
ret := m.ctrl.Call(m, "IterateRoot", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// IterateRoot indicates an expected call of IterateRoot.
func (mr *MockSyncTreeMockRecorder) IterateRoot(convert, iterate any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) IterateRoot(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockSyncTree)(nil).IterateRoot), convert, iterate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockSyncTree)(nil).IterateRoot), arg0, arg1)
}
// Len mocks base method.
@ -433,18 +400,18 @@ func (mr *MockSyncTreeMockRecorder) Lock() *gomock.Call {
}
// PrepareChange mocks base method.
func (m *MockSyncTree) PrepareChange(content objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockSyncTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PrepareChange", content)
ret := m.ctrl.Call(m, "PrepareChange", arg0)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PrepareChange indicates an expected call of PrepareChange.
func (mr *MockSyncTreeMockRecorder) PrepareChange(content any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) PrepareChange(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockSyncTree)(nil).PrepareChange), content)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockSyncTree)(nil).PrepareChange), arg0)
}
// ResponseCollector mocks base method.
@ -476,27 +443,27 @@ func (mr *MockSyncTreeMockRecorder) Root() *gomock.Call {
}
// SetFlusher mocks base method.
func (m *MockSyncTree) SetFlusher(flusher objecttree.Flusher) {
func (m *MockSyncTree) SetFlusher(arg0 objecttree.Flusher) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetFlusher", flusher)
m.ctrl.Call(m, "SetFlusher", arg0)
}
// SetFlusher indicates an expected call of SetFlusher.
func (mr *MockSyncTreeMockRecorder) SetFlusher(flusher any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) SetFlusher(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlusher", reflect.TypeOf((*MockSyncTree)(nil).SetFlusher), flusher)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlusher", reflect.TypeOf((*MockSyncTree)(nil).SetFlusher), arg0)
}
// SetListener mocks base method.
func (m *MockSyncTree) SetListener(listener updatelistener.UpdateListener) {
func (m *MockSyncTree) SetListener(arg0 updatelistener.UpdateListener) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetListener", listener)
m.ctrl.Call(m, "SetListener", arg0)
}
// SetListener indicates an expected call of SetListener.
func (mr *MockSyncTreeMockRecorder) SetListener(listener any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) SetListener(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetListener", reflect.TypeOf((*MockSyncTree)(nil).SetListener), listener)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetListener", reflect.TypeOf((*MockSyncTree)(nil).SetListener), arg0)
}
// SnapshotPath mocks base method.
@ -514,10 +481,10 @@ func (mr *MockSyncTreeMockRecorder) SnapshotPath() *gomock.Call {
}
// Storage mocks base method.
func (m *MockSyncTree) Storage() treestorage.TreeStorage {
func (m *MockSyncTree) Storage() objecttree.Storage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Storage")
ret0, _ := ret[0].(treestorage.TreeStorage)
ret0, _ := ret[0].(objecttree.Storage)
return ret0
}
@ -528,32 +495,32 @@ func (mr *MockSyncTreeMockRecorder) Storage() *gomock.Call {
}
// SyncWithPeer mocks base method.
func (m *MockSyncTree) SyncWithPeer(ctx context.Context, p peer.Peer) error {
func (m *MockSyncTree) SyncWithPeer(arg0 context.Context, arg1 peer.Peer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SyncWithPeer", ctx, p)
ret := m.ctrl.Call(m, "SyncWithPeer", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// SyncWithPeer indicates an expected call of SyncWithPeer.
func (mr *MockSyncTreeMockRecorder) SyncWithPeer(ctx, p any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) SyncWithPeer(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncTree)(nil).SyncWithPeer), ctx, p)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncTree)(nil).SyncWithPeer), arg0, arg1)
}
// TryClose mocks base method.
func (m *MockSyncTree) TryClose(objectTTL time.Duration) (bool, error) {
func (m *MockSyncTree) TryClose(arg0 time.Duration) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TryClose", objectTTL)
ret := m.ctrl.Call(m, "TryClose", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TryClose indicates an expected call of TryClose.
func (mr *MockSyncTreeMockRecorder) TryClose(objectTTL any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) TryClose(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockSyncTree)(nil).TryClose), objectTTL)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockSyncTree)(nil).TryClose), arg0)
}
// TryLock mocks base method.
@ -597,25 +564,24 @@ func (mr *MockSyncTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
}
// UnpackChange mocks base method.
func (m *MockSyncTree) UnpackChange(raw *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
func (m *MockSyncTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UnpackChange", raw)
ret := m.ctrl.Call(m, "UnpackChange", arg0)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UnpackChange indicates an expected call of UnpackChange.
func (mr *MockSyncTreeMockRecorder) UnpackChange(raw any) *gomock.Call {
func (mr *MockSyncTreeMockRecorder) UnpackChange(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockSyncTree)(nil).UnpackChange), raw)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockSyncTree)(nil).UnpackChange), arg0)
}
// MockHeadNotifiable is a mock of HeadNotifiable interface.
type MockHeadNotifiable struct {
ctrl *gomock.Controller
recorder *MockHeadNotifiableMockRecorder
isgomock struct{}
}
// MockHeadNotifiableMockRecorder is the mock recorder for MockHeadNotifiable.
@ -636,22 +602,21 @@ func (m *MockHeadNotifiable) EXPECT() *MockHeadNotifiableMockRecorder {
}
// UpdateHeads mocks base method.
func (m *MockHeadNotifiable) UpdateHeads(id string, heads []string) {
func (m *MockHeadNotifiable) UpdateHeads(arg0 string, arg1 []string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdateHeads", id, heads)
m.ctrl.Call(m, "UpdateHeads", arg0, arg1)
}
// UpdateHeads indicates an expected call of UpdateHeads.
func (mr *MockHeadNotifiableMockRecorder) UpdateHeads(id, heads any) *gomock.Call {
func (mr *MockHeadNotifiableMockRecorder) UpdateHeads(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHeads", reflect.TypeOf((*MockHeadNotifiable)(nil).UpdateHeads), id, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHeads", reflect.TypeOf((*MockHeadNotifiable)(nil).UpdateHeads), arg0, arg1)
}
// MockSyncClient is a mock of SyncClient interface.
type MockSyncClient struct {
ctrl *gomock.Controller
recorder *MockSyncClientMockRecorder
isgomock struct{}
}
// MockSyncClientMockRecorder is the mock recorder for MockSyncClient.
@ -672,110 +637,109 @@ func (m *MockSyncClient) EXPECT() *MockSyncClientMockRecorder {
}
// Broadcast mocks base method.
func (m *MockSyncClient) Broadcast(ctx context.Context, headUpdate *objectmessages.HeadUpdate) error {
func (m *MockSyncClient) Broadcast(arg0 context.Context, arg1 *objectmessages.HeadUpdate) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Broadcast", ctx, headUpdate)
ret := m.ctrl.Call(m, "Broadcast", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Broadcast indicates an expected call of Broadcast.
func (mr *MockSyncClientMockRecorder) Broadcast(ctx, headUpdate any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) Broadcast(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), ctx, headUpdate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), arg0, arg1)
}
// CreateFullSyncRequest mocks base method.
func (m *MockSyncClient) CreateFullSyncRequest(peerId string, t objecttree.ObjectTree) *objectmessages.Request {
func (m *MockSyncClient) CreateFullSyncRequest(arg0 string, arg1 objecttree.ObjectTree) *objectmessages.Request {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateFullSyncRequest", peerId, t)
ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1)
ret0, _ := ret[0].(*objectmessages.Request)
return ret0
}
// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(peerId, t any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), peerId, t)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), arg0, arg1)
}
// CreateHeadUpdate mocks base method.
func (m *MockSyncClient) CreateHeadUpdate(t objecttree.ObjectTree, ignoredPeer string, added []*treechangeproto.RawTreeChangeWithId) (*objectmessages.HeadUpdate, error) {
func (m *MockSyncClient) CreateHeadUpdate(arg0 objecttree.ObjectTree, arg1 string, arg2 []*treechangeproto.RawTreeChangeWithId) (*objectmessages.HeadUpdate, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateHeadUpdate", t, ignoredPeer, added)
ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1, arg2)
ret0, _ := ret[0].(*objectmessages.HeadUpdate)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(t, ignoredPeer, added any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), t, ignoredPeer, added)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), arg0, arg1, arg2)
}
// CreateNewTreeRequest mocks base method.
func (m *MockSyncClient) CreateNewTreeRequest(peerId, objectId string) *objectmessages.Request {
func (m *MockSyncClient) CreateNewTreeRequest(arg0, arg1 string) *objectmessages.Request {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateNewTreeRequest", peerId, objectId)
ret := m.ctrl.Call(m, "CreateNewTreeRequest", arg0, arg1)
ret0, _ := ret[0].(*objectmessages.Request)
return ret0
}
// CreateNewTreeRequest indicates an expected call of CreateNewTreeRequest.
func (mr *MockSyncClientMockRecorder) CreateNewTreeRequest(peerId, objectId any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateNewTreeRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewTreeRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateNewTreeRequest), peerId, objectId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewTreeRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateNewTreeRequest), arg0, arg1)
}
// CreateResponseProducer mocks base method.
func (m *MockSyncClient) CreateResponseProducer(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (response.ResponseProducer, error) {
func (m *MockSyncClient) CreateResponseProducer(arg0 objecttree.ObjectTree, arg1, arg2 []string) (response.ResponseProducer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateResponseProducer", t, theirHeads, theirSnapshotPath)
ret := m.ctrl.Call(m, "CreateResponseProducer", arg0, arg1, arg2)
ret0, _ := ret[0].(response.ResponseProducer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateResponseProducer indicates an expected call of CreateResponseProducer.
func (mr *MockSyncClientMockRecorder) CreateResponseProducer(t, theirHeads, theirSnapshotPath any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) CreateResponseProducer(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResponseProducer", reflect.TypeOf((*MockSyncClient)(nil).CreateResponseProducer), t, theirHeads, theirSnapshotPath)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResponseProducer", reflect.TypeOf((*MockSyncClient)(nil).CreateResponseProducer), arg0, arg1, arg2)
}
// QueueRequest mocks base method.
func (m *MockSyncClient) QueueRequest(ctx context.Context, req syncdeps.Request) error {
func (m *MockSyncClient) QueueRequest(arg0 context.Context, arg1 syncdeps.Request) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "QueueRequest", ctx, req)
ret := m.ctrl.Call(m, "QueueRequest", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// QueueRequest indicates an expected call of QueueRequest.
func (mr *MockSyncClientMockRecorder) QueueRequest(ctx, req any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) QueueRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueRequest", reflect.TypeOf((*MockSyncClient)(nil).QueueRequest), ctx, req)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueRequest", reflect.TypeOf((*MockSyncClient)(nil).QueueRequest), arg0, arg1)
}
// SendTreeRequest mocks base method.
func (m *MockSyncClient) SendTreeRequest(ctx context.Context, req syncdeps.Request, collector syncdeps.ResponseCollector) error {
func (m *MockSyncClient) SendTreeRequest(arg0 context.Context, arg1 syncdeps.Request, arg2 syncdeps.ResponseCollector) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendTreeRequest", ctx, req, collector)
ret := m.ctrl.Call(m, "SendTreeRequest", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// SendTreeRequest indicates an expected call of SendTreeRequest.
func (mr *MockSyncClientMockRecorder) SendTreeRequest(ctx, req, collector any) *gomock.Call {
func (mr *MockSyncClientMockRecorder) SendTreeRequest(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTreeRequest", reflect.TypeOf((*MockSyncClient)(nil).SendTreeRequest), ctx, req, collector)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTreeRequest", reflect.TypeOf((*MockSyncClient)(nil).SendTreeRequest), arg0, arg1, arg2)
}
// MockRequestFactory is a mock of RequestFactory interface.
type MockRequestFactory struct {
ctrl *gomock.Controller
recorder *MockRequestFactoryMockRecorder
isgomock struct{}
}
// MockRequestFactoryMockRecorder is the mock recorder for MockRequestFactory.
@ -796,59 +760,59 @@ func (m *MockRequestFactory) EXPECT() *MockRequestFactoryMockRecorder {
}
// CreateFullSyncRequest mocks base method.
func (m *MockRequestFactory) CreateFullSyncRequest(peerId string, t objecttree.ObjectTree) *objectmessages.Request {
func (m *MockRequestFactory) CreateFullSyncRequest(arg0 string, arg1 objecttree.ObjectTree) *objectmessages.Request {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateFullSyncRequest", peerId, t)
ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1)
ret0, _ := ret[0].(*objectmessages.Request)
return ret0
}
// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
func (mr *MockRequestFactoryMockRecorder) CreateFullSyncRequest(peerId, t any) *gomock.Call {
func (mr *MockRequestFactoryMockRecorder) CreateFullSyncRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockRequestFactory)(nil).CreateFullSyncRequest), peerId, t)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockRequestFactory)(nil).CreateFullSyncRequest), arg0, arg1)
}
// CreateHeadUpdate mocks base method.
func (m *MockRequestFactory) CreateHeadUpdate(t objecttree.ObjectTree, ignoredPeer string, added []*treechangeproto.RawTreeChangeWithId) (*objectmessages.HeadUpdate, error) {
func (m *MockRequestFactory) CreateHeadUpdate(arg0 objecttree.ObjectTree, arg1 string, arg2 []*treechangeproto.RawTreeChangeWithId) (*objectmessages.HeadUpdate, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateHeadUpdate", t, ignoredPeer, added)
ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1, arg2)
ret0, _ := ret[0].(*objectmessages.HeadUpdate)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
func (mr *MockRequestFactoryMockRecorder) CreateHeadUpdate(t, ignoredPeer, added any) *gomock.Call {
func (mr *MockRequestFactoryMockRecorder) CreateHeadUpdate(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockRequestFactory)(nil).CreateHeadUpdate), t, ignoredPeer, added)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockRequestFactory)(nil).CreateHeadUpdate), arg0, arg1, arg2)
}
// CreateNewTreeRequest mocks base method.
func (m *MockRequestFactory) CreateNewTreeRequest(peerId, objectId string) *objectmessages.Request {
func (m *MockRequestFactory) CreateNewTreeRequest(arg0, arg1 string) *objectmessages.Request {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateNewTreeRequest", peerId, objectId)
ret := m.ctrl.Call(m, "CreateNewTreeRequest", arg0, arg1)
ret0, _ := ret[0].(*objectmessages.Request)
return ret0
}
// CreateNewTreeRequest indicates an expected call of CreateNewTreeRequest.
func (mr *MockRequestFactoryMockRecorder) CreateNewTreeRequest(peerId, objectId any) *gomock.Call {
func (mr *MockRequestFactoryMockRecorder) CreateNewTreeRequest(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewTreeRequest", reflect.TypeOf((*MockRequestFactory)(nil).CreateNewTreeRequest), peerId, objectId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewTreeRequest", reflect.TypeOf((*MockRequestFactory)(nil).CreateNewTreeRequest), arg0, arg1)
}
// CreateResponseProducer mocks base method.
func (m *MockRequestFactory) CreateResponseProducer(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (response.ResponseProducer, error) {
func (m *MockRequestFactory) CreateResponseProducer(arg0 objecttree.ObjectTree, arg1, arg2 []string) (response.ResponseProducer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateResponseProducer", t, theirHeads, theirSnapshotPath)
ret := m.ctrl.Call(m, "CreateResponseProducer", arg0, arg1, arg2)
ret0, _ := ret[0].(response.ResponseProducer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateResponseProducer indicates an expected call of CreateResponseProducer.
func (mr *MockRequestFactoryMockRecorder) CreateResponseProducer(t, theirHeads, theirSnapshotPath any) *gomock.Call {
func (mr *MockRequestFactoryMockRecorder) CreateResponseProducer(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResponseProducer", reflect.TypeOf((*MockRequestFactory)(nil).CreateResponseProducer), t, theirHeads, theirSnapshotPath)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResponseProducer", reflect.TypeOf((*MockRequestFactory)(nil).CreateResponseProducer), arg0, arg1, arg2)
}

9
commonspace/object/tree/synctree/response/mock_response/mock_response.go
View file

@ -20,7 +20,6 @@ import (
type MockResponseProducer struct {
ctrl *gomock.Controller
recorder *MockResponseProducerMockRecorder
isgomock struct{}
}
// MockResponseProducerMockRecorder is the mock recorder for MockResponseProducer.
@ -55,16 +54,16 @@ func (mr *MockResponseProducerMockRecorder) EmptyResponse() *gomock.Call {
}
// NewResponse mocks base method.
func (m *MockResponseProducer) NewResponse(batchSize int) (*response.Response, error) {
func (m *MockResponseProducer) NewResponse(arg0 int) (*response.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NewResponse", batchSize)
ret := m.ctrl.Call(m, "NewResponse", arg0)
ret0, _ := ret[0].(*response.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// NewResponse indicates an expected call of NewResponse.
func (mr *MockResponseProducerMockRecorder) NewResponse(batchSize any) *gomock.Call {
func (mr *MockResponseProducerMockRecorder) NewResponse(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewResponse", reflect.TypeOf((*MockResponseProducer)(nil).NewResponse), batchSize)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewResponse", reflect.TypeOf((*MockResponseProducer)(nil).NewResponse), arg0)
}

10
commonspace/object/tree/synctree/synchandler_test.go
View file

@ -52,8 +52,9 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
ctx = peer.CtxWithPeerId(ctx, "peerId")
fx.syncStatus.EXPECT().HeadsReceive("peerId", "objectId", heads)
fx.tree.EXPECT().AddRawChangesFromPeer(ctx, "peerId", objecttree.RawChangesPayload{
NewHeads: heads,
RawChanges: changes,
NewHeads: heads,
RawChanges: changes,
SnapshotPath: []string{rawCh.Id},
}).Return(objecttree.AddResult{
OldHeads: []string{"head"},
Heads: heads,
@ -92,8 +93,9 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
ctx = peer.CtxWithPeerId(ctx, "peerId")
fx.syncStatus.EXPECT().HeadsReceive("peerId", "objectId", heads)
fx.tree.EXPECT().AddRawChangesFromPeer(ctx, "peerId", objecttree.RawChangesPayload{
NewHeads: heads,
RawChanges: changes,
NewHeads: heads,
RawChanges: changes,
SnapshotPath: []string{rawCh.Id},
}).Return(objecttree.AddResult{
OldHeads: []string{"head"},
Heads: []string{"other"},

52
commonspace/object/tree/synctree/synctree_test.go
View file

@ -7,6 +7,8 @@ import (
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
"github.com/anyproto/any-sync/commonspace/headsync/headstorage"
"github.com/anyproto/any-sync/commonspace/headsync/headstorage/mock_headstorage"
"github.com/anyproto/any-sync/commonspace/object/acl/list"
"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
"github.com/anyproto/any-sync/commonspace/object/tree/objecttree/mock_objecttree"
@ -68,6 +70,7 @@ type fixture struct {
objTree *testObjMock
listener *mock_updatelistener.MockUpdateListener
headNotifiable *mock_synctree.MockHeadNotifiable
headStorage *mock_headstorage.MockHeadStorage
syncStatus *mock_syncstatus.MockStatusUpdater
spaceStorage *mock_spacestorage.MockSpaceStorage
deps BuildDeps
@ -85,6 +88,7 @@ func newFixture(t *testing.T) *fixture {
headNotifiable := mock_synctree.NewMockHeadNotifiable(ctrl)
syncStatus := mock_syncstatus.NewMockStatusUpdater(ctrl)
spaceStorage := mock_spacestorage.NewMockSpaceStorage(ctrl)
headStorage := mock_headstorage.NewMockHeadStorage(ctrl)
deps := BuildDeps{
SyncClient: syncClient,
Listener: listener,
@ -103,6 +107,7 @@ func newFixture(t *testing.T) *fixture {
headNotifiable: headNotifiable,
syncStatus: syncStatus,
spaceStorage: spaceStorage,
headStorage: headStorage,
deps: deps,
}
}
@ -119,7 +124,6 @@ func Test_BuildSyncTree(t *testing.T) {
fx.objTree.EXPECT().Heads().AnyTimes().Return([]string{"headId"})
fx.objTree.EXPECT().Id().AnyTimes().Return("id")
fx.objTree.EXPECT().IsDerived().AnyTimes().Return(false)
fx.headNotifiable.EXPECT().UpdateHeads("id", []string{"headId"})
fx.listener.EXPECT().Rebuild(gomock.Any())
headUpdate := &objectmessages.HeadUpdate{
Bytes: []byte("bytes"),
@ -140,7 +144,6 @@ func Test_BuildSyncTree(t *testing.T) {
fx.objTree.EXPECT().Heads().AnyTimes().Return([]string{"headId"})
fx.objTree.EXPECT().Id().AnyTimes().Return("id")
fx.objTree.EXPECT().IsDerived().AnyTimes().Return(false)
fx.headNotifiable.EXPECT().UpdateHeads("id", []string{"headId"})
fx.listener.EXPECT().Rebuild(gomock.Any())
res, err := BuildSyncTreeOrGetRemote(ctx, "id", fx.deps)
require.NoError(t, err)
@ -152,21 +155,21 @@ func Test_PutSyncTree(t *testing.T) {
t.Run("put sync tree ok", func(t *testing.T) {
fx := newFixture(t)
defer fx.finish()
fx.spaceStorage.EXPECT().CreateTreeStorage(gomock.Any()).Return(nil, nil)
fx.spaceStorage.EXPECT().CreateTreeStorage(gomock.Any(), gomock.Any()).Return(nil, nil)
fx.objTree.EXPECT().Heads().AnyTimes().Return([]string{"headId"})
fx.objTree.EXPECT().Id().AnyTimes().Return("id")
fx.objTree.EXPECT().IsDerived().AnyTimes().Return(false)
fx.headNotifiable.EXPECT().UpdateHeads("id", []string{"headId"})
fx.listener.EXPECT().Rebuild(gomock.Any())
headUpdate := &objectmessages.HeadUpdate{
Bytes: []byte("bytes"),
}
fx.syncClient.EXPECT().CreateHeadUpdate(gomock.Any(), "", nil).Return(headUpdate, nil)
fx.syncClient.EXPECT().Broadcast(gomock.Any(), headUpdate)
fx.spaceStorage.EXPECT().TreeDeletedStatus("rootId").Return("", nil)
fx.spaceStorage.EXPECT().HeadStorage().Return(fx.headStorage)
fx.headStorage.EXPECT().GetEntry(gomock.Any(), "id").Return(headstorage.HeadsEntry{}, nil)
res, err := PutSyncTree(ctx, treestorage.TreeStorageCreatePayload{
RootRawChange: &treechangeproto.RawTreeChangeWithId{
Id: "rootId",
Id: "id",
},
}, fx.deps)
require.NoError(t, err)
@ -175,17 +178,18 @@ func Test_PutSyncTree(t *testing.T) {
t.Run("put sync tree derived, one change", func(t *testing.T) {
fx := newFixture(t)
defer fx.finish()
fx.spaceStorage.EXPECT().CreateTreeStorage(gomock.Any()).Return(nil, nil)
fx.spaceStorage.EXPECT().CreateTreeStorage(gomock.Any(), gomock.Any()).Return(nil, nil)
fx.objTree.EXPECT().Heads().AnyTimes().Return([]string{"id"})
fx.objTree.EXPECT().Id().AnyTimes().Return("id")
fx.objTree.EXPECT().Root().AnyTimes().Return(&objecttree.Change{Id: "id"})
fx.objTree.EXPECT().IsDerived().AnyTimes().Return(true)
fx.objTree.EXPECT().Len().AnyTimes().Return(1)
fx.listener.EXPECT().Rebuild(gomock.Any())
fx.spaceStorage.EXPECT().TreeDeletedStatus("rootId").Return("", nil)
fx.spaceStorage.EXPECT().HeadStorage().Return(fx.headStorage)
fx.headStorage.EXPECT().GetEntry(gomock.Any(), "id").Return(headstorage.HeadsEntry{}, nil)
res, err := PutSyncTree(ctx, treestorage.TreeStorageCreatePayload{
RootRawChange: &treechangeproto.RawTreeChangeWithId{
Id: "rootId",
Id: "id",
},
}, fx.deps)
require.NoError(t, err)
@ -194,10 +198,11 @@ func Test_PutSyncTree(t *testing.T) {
t.Run("put sync tree already deleted", func(t *testing.T) {
fx := newFixture(t)
defer fx.finish()
fx.spaceStorage.EXPECT().TreeDeletedStatus("rootId").Return("deleted", nil)
fx.spaceStorage.EXPECT().HeadStorage().Return(fx.headStorage)
fx.headStorage.EXPECT().GetEntry(gomock.Any(), "id").Return(headstorage.HeadsEntry{DeletedStatus: headstorage.DeletedStatusDeleted}, nil)
res, err := PutSyncTree(ctx, treestorage.TreeStorageCreatePayload{
RootRawChange: &treechangeproto.RawTreeChangeWithId{
Id: "rootId",
Id: "id",
},
}, fx.deps)
require.Equal(t, spacestorage.ErrTreeStorageAlreadyDeleted, err)
@ -215,13 +220,11 @@ func Test_SyncTree(t *testing.T) {
objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
objTreeMock.EXPECT().Id().AnyTimes().Return("id")
syncStatusMock := mock_syncstatus.NewMockStatusUpdater(ctrl)
notifiableMock := mock_synctree.NewMockHeadNotifiable(ctrl)
tr := &syncTree{
ObjectTree: objTreeMock,
syncClient: syncClientMock,
listener: updateListenerMock,
notifiable: notifiableMock,
isClosed: false,
syncStatus: syncStatusMock,
}
@ -251,10 +254,9 @@ func Test_SyncTree(t *testing.T) {
}
return expectedRes, nil
})
notifiableMock.EXPECT().UpdateHeads("id", []string{"headId1"})
updateListenerMock.EXPECT().Update(tr).Return(nil)
syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), "peerId", gomock.Eq(changes)).Return(headUpdate, nil)
syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), "peerId", gomock.Eq(rawChanges)).Return(headUpdate, nil)
syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate))
syncStatusMock.EXPECT().HeadsApply("peerId", "id", []string{"headId1"}, true)
res, err := tr.AddRawChangesFromPeer(ctx, "peerId", payload)
@ -262,11 +264,12 @@ func Test_SyncTree(t *testing.T) {
require.Equal(t, expectedRes, res)
})
t.Run("AddRawChangesFromPeer rebuild", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
rawChanges := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
payload := objecttree.RawChangesPayload{
NewHeads: []string{"headId1"},
RawChanges: changes,
RawChanges: rawChanges,
}
changes := []objecttree.StorageChange{{Id: "some"}}
expectedRes := objecttree.AddResult{
Added: changes,
OldHeads: []string{"headId"},
@ -284,10 +287,9 @@ func Test_SyncTree(t *testing.T) {
}
return expectedRes, nil
})
notifiableMock.EXPECT().UpdateHeads("id", []string{"headId1"})
updateListenerMock.EXPECT().Rebuild(tr).Return(nil)
syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), "peerId", gomock.Eq(changes)).Return(headUpdate, nil)
syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), "peerId", gomock.Eq(rawChanges)).Return(headUpdate, nil)
syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate))
syncStatusMock.EXPECT().HeadsApply("peerId", "id", []string{"headId1"}, true)
res, err := tr.AddRawChangesFromPeer(ctx, "peerId", payload)
@ -295,10 +297,10 @@ func Test_SyncTree(t *testing.T) {
require.Equal(t, expectedRes, res)
})
t.Run("AddRawChangesFromPeer hasHeads nothing", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
rawChanges := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
payload := objecttree.RawChangesPayload{
NewHeads: []string{"headId"},
RawChanges: changes,
RawChanges: rawChanges,
}
expectedRes := objecttree.AddResult{
OldHeads: []string{"headId"},
@ -340,21 +342,21 @@ func Test_SyncTree(t *testing.T) {
})
t.Run("AddContent", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
changes := []objecttree.StorageChange{{Id: "some"}}
rawChanges := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
content := objecttree.SignableChangeContent{
Data: []byte("abcde"),
}
expectedRes := objecttree.AddResult{
Added: changes,
Mode: objecttree.Append,
Heads: []string{"headId"},
Added: changes,
}
objTreeMock.EXPECT().Id().Return("id").AnyTimes()
objTreeMock.EXPECT().AddContentWithValidator(gomock.Any(), gomock.Eq(content), gomock.Any()).
Return(expectedRes, nil)
syncStatusMock.EXPECT().HeadsChange("id", []string{"headId"})
notifiableMock.EXPECT().UpdateHeads("id", []string{"headId"})
syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), "", gomock.Eq(changes)).Return(headUpdate, nil)
syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), "", gomock.Eq(rawChanges)).Return(headUpdate, nil)
syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate))
res, err := tr.AddContent(ctx, content)
require.NoError(t, err)

17
commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go
View file

@ -20,7 +20,6 @@ import (
type MockUpdateListener struct {
ctrl *gomock.Controller
recorder *MockUpdateListenerMockRecorder
isgomock struct{}
}
// MockUpdateListenerMockRecorder is the mock recorder for MockUpdateListener.
@ -41,29 +40,29 @@ func (m *MockUpdateListener) EXPECT() *MockUpdateListenerMockRecorder {
}
// Rebuild mocks base method.
func (m *MockUpdateListener) Rebuild(tree objecttree.ObjectTree) error {
func (m *MockUpdateListener) Rebuild(arg0 objecttree.ObjectTree) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Rebuild", tree)
ret := m.ctrl.Call(m, "Rebuild", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Rebuild indicates an expected call of Rebuild.
func (mr *MockUpdateListenerMockRecorder) Rebuild(tree any) *gomock.Call {
func (mr *MockUpdateListenerMockRecorder) Rebuild(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebuild", reflect.TypeOf((*MockUpdateListener)(nil).Rebuild), tree)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebuild", reflect.TypeOf((*MockUpdateListener)(nil).Rebuild), arg0)
}
// Update mocks base method.
func (m *MockUpdateListener) Update(tree objecttree.ObjectTree) error {
func (m *MockUpdateListener) Update(arg0 objecttree.ObjectTree) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", tree)
ret := m.ctrl.Call(m, "Update", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Update indicates an expected call of Update.
func (mr *MockUpdateListenerMockRecorder) Update(tree any) *gomock.Call {
func (mr *MockUpdateListenerMockRecorder) Update(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUpdateListener)(nil).Update), tree)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUpdateListener)(nil).Update), arg0)
}

1
commonspace/object/tree/treestorage/treestorage.go
View file

@ -1,4 +1,3 @@
//go:generate mockgen -destination mock_treestorage/mock_treestorage.go github.com/anyproto/any-sync/commonspace/object/tree/treestorage TreeStorage
package treestorage
import (

57
commonspace/object/treemanager/mock_treemanager/mock_treemanager.go
View file

@ -23,7 +23,6 @@ import (
type MockTreeManager struct {
ctrl *gomock.Controller
recorder *MockTreeManagerMockRecorder
isgomock struct{}
}
// MockTreeManagerMockRecorder is the mock recorder for MockTreeManager.
@ -44,74 +43,74 @@ func (m *MockTreeManager) EXPECT() *MockTreeManagerMockRecorder {
}
// Close mocks base method.
func (m *MockTreeManager) Close(ctx context.Context) error {
func (m *MockTreeManager) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockTreeManagerMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeManager)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeManager)(nil).Close), arg0)
}
// DeleteTree mocks base method.
func (m *MockTreeManager) DeleteTree(ctx context.Context, spaceId, treeId string) error {
func (m *MockTreeManager) DeleteTree(arg0 context.Context, arg1, arg2 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteTree", ctx, spaceId, treeId)
ret := m.ctrl.Call(m, "DeleteTree", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteTree indicates an expected call of DeleteTree.
func (mr *MockTreeManagerMockRecorder) DeleteTree(ctx, spaceId, treeId any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) DeleteTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockTreeManager)(nil).DeleteTree), ctx, spaceId, treeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockTreeManager)(nil).DeleteTree), arg0, arg1, arg2)
}
// GetTree mocks base method.
func (m *MockTreeManager) GetTree(ctx context.Context, spaceId, treeId string) (objecttree.ObjectTree, error) {
func (m *MockTreeManager) GetTree(arg0 context.Context, arg1, arg2 string) (objecttree.ObjectTree, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetTree", ctx, spaceId, treeId)
ret := m.ctrl.Call(m, "GetTree", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.ObjectTree)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetTree indicates an expected call of GetTree.
func (mr *MockTreeManagerMockRecorder) GetTree(ctx, spaceId, treeId any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) GetTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockTreeManager)(nil).GetTree), ctx, spaceId, treeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockTreeManager)(nil).GetTree), arg0, arg1, arg2)
}
// Init mocks base method.
func (m *MockTreeManager) Init(a *app.App) error {
func (m *MockTreeManager) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockTreeManagerMockRecorder) Init(a any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeManager)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeManager)(nil).Init), arg0)
}
// MarkTreeDeleted mocks base method.
func (m *MockTreeManager) MarkTreeDeleted(ctx context.Context, spaceId, treeId string) error {
func (m *MockTreeManager) MarkTreeDeleted(arg0 context.Context, arg1, arg2 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MarkTreeDeleted", ctx, spaceId, treeId)
ret := m.ctrl.Call(m, "MarkTreeDeleted", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// MarkTreeDeleted indicates an expected call of MarkTreeDeleted.
func (mr *MockTreeManagerMockRecorder) MarkTreeDeleted(ctx, spaceId, treeId any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) MarkTreeDeleted(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTreeDeleted", reflect.TypeOf((*MockTreeManager)(nil).MarkTreeDeleted), ctx, spaceId, treeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTreeDeleted", reflect.TypeOf((*MockTreeManager)(nil).MarkTreeDeleted), arg0, arg1, arg2)
}
// Name mocks base method.
@ -129,29 +128,29 @@ func (mr *MockTreeManagerMockRecorder) Name() *gomock.Call {
}
// Run mocks base method.
func (m *MockTreeManager) Run(ctx context.Context) error {
func (m *MockTreeManager) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockTreeManagerMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeManager)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeManager)(nil).Run), arg0)
}
// ValidateAndPutTree mocks base method.
func (m *MockTreeManager) ValidateAndPutTree(ctx context.Context, spaceId string, payload treestorage.TreeStorageCreatePayload) error {
func (m *MockTreeManager) ValidateAndPutTree(arg0 context.Context, arg1 string, arg2 treestorage.TreeStorageCreatePayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateAndPutTree", ctx, spaceId, payload)
ret := m.ctrl.Call(m, "ValidateAndPutTree", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// ValidateAndPutTree indicates an expected call of ValidateAndPutTree.
func (mr *MockTreeManagerMockRecorder) ValidateAndPutTree(ctx, spaceId, payload any) *gomock.Call {
func (mr *MockTreeManagerMockRecorder) ValidateAndPutTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAndPutTree", reflect.TypeOf((*MockTreeManager)(nil).ValidateAndPutTree), ctx, spaceId, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAndPutTree", reflect.TypeOf((*MockTreeManager)(nil).ValidateAndPutTree), arg0, arg1, arg2)
}

41
commonspace/object/treesyncer/mock_treesyncer/mock_treesyncer.go
View file

@ -22,7 +22,6 @@ import (
type MockTreeSyncer struct {
ctrl *gomock.Controller
recorder *MockTreeSyncerMockRecorder
isgomock struct{}
}
// MockTreeSyncerMockRecorder is the mock recorder for MockTreeSyncer.
@ -43,31 +42,31 @@ func (m *MockTreeSyncer) EXPECT() *MockTreeSyncerMockRecorder {
}
// Close mocks base method.
func (m *MockTreeSyncer) Close(ctx context.Context) error {
func (m *MockTreeSyncer) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockTreeSyncerMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockTreeSyncerMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeSyncer)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeSyncer)(nil).Close), arg0)
}
// Init mocks base method.
func (m *MockTreeSyncer) Init(a *app.App) error {
func (m *MockTreeSyncer) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockTreeSyncerMockRecorder) Init(a any) *gomock.Call {
func (mr *MockTreeSyncerMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeSyncer)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeSyncer)(nil).Init), arg0)
}
// Name mocks base method.
@ -85,31 +84,31 @@ func (mr *MockTreeSyncerMockRecorder) Name() *gomock.Call {
}
// Run mocks base method.
func (m *MockTreeSyncer) Run(ctx context.Context) error {
func (m *MockTreeSyncer) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockTreeSyncerMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockTreeSyncerMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeSyncer)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeSyncer)(nil).Run), arg0)
}
// ShouldSync mocks base method.
func (m *MockTreeSyncer) ShouldSync(peerId string) bool {
func (m *MockTreeSyncer) ShouldSync(arg0 string) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ShouldSync", peerId)
ret := m.ctrl.Call(m, "ShouldSync", arg0)
ret0, _ := ret[0].(bool)
return ret0
}
// ShouldSync indicates an expected call of ShouldSync.
func (mr *MockTreeSyncerMockRecorder) ShouldSync(peerId any) *gomock.Call {
func (mr *MockTreeSyncerMockRecorder) ShouldSync(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldSync", reflect.TypeOf((*MockTreeSyncer)(nil).ShouldSync), peerId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldSync", reflect.TypeOf((*MockTreeSyncer)(nil).ShouldSync), arg0)
}
// StartSync mocks base method.
@ -137,15 +136,15 @@ func (mr *MockTreeSyncerMockRecorder) StopSync() *gomock.Call {
}
// SyncAll mocks base method.
func (m *MockTreeSyncer) SyncAll(ctx context.Context, p peer.Peer, existing, missing []string) error {
func (m *MockTreeSyncer) SyncAll(arg0 context.Context, arg1 peer.Peer, arg2, arg3 []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SyncAll", ctx, p, existing, missing)
ret := m.ctrl.Call(m, "SyncAll", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// SyncAll indicates an expected call of SyncAll.
func (mr *MockTreeSyncerMockRecorder) SyncAll(ctx, p, existing, missing any) *gomock.Call {
func (mr *MockTreeSyncerMockRecorder) SyncAll(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncAll", reflect.TypeOf((*MockTreeSyncer)(nil).SyncAll), ctx, p, existing, missing)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncAll", reflect.TypeOf((*MockTreeSyncer)(nil).SyncAll), arg0, arg1, arg2, arg3)
}

73
commonspace/objectmanager/mock_objectmanager/mock_objectmanager.go
View file

@ -24,7 +24,6 @@ import (
type MockObjectManager struct {
ctrl *gomock.Controller
recorder *MockObjectManagerMockRecorder
isgomock struct{}
}
// MockObjectManagerMockRecorder is the mock recorder for MockObjectManager.
@ -45,101 +44,101 @@ func (m *MockObjectManager) EXPECT() *MockObjectManagerMockRecorder {
}
// AddObject mocks base method.
func (m *MockObjectManager) AddObject(object syncobjectgetter.SyncObject) {
func (m *MockObjectManager) AddObject(arg0 syncobjectgetter.SyncObject) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AddObject", object)
m.ctrl.Call(m, "AddObject", arg0)
}
// AddObject indicates an expected call of AddObject.
func (mr *MockObjectManagerMockRecorder) AddObject(object any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) AddObject(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObject", reflect.TypeOf((*MockObjectManager)(nil).AddObject), object)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObject", reflect.TypeOf((*MockObjectManager)(nil).AddObject), arg0)
}
// Close mocks base method.
func (m *MockObjectManager) Close(ctx context.Context) error {
func (m *MockObjectManager) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockObjectManagerMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockObjectManager)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockObjectManager)(nil).Close), arg0)
}
// DeleteTree mocks base method.
func (m *MockObjectManager) DeleteTree(ctx context.Context, spaceId, treeId string) error {
func (m *MockObjectManager) DeleteTree(arg0 context.Context, arg1, arg2 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteTree", ctx, spaceId, treeId)
ret := m.ctrl.Call(m, "DeleteTree", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteTree indicates an expected call of DeleteTree.
func (mr *MockObjectManagerMockRecorder) DeleteTree(ctx, spaceId, treeId any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) DeleteTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockObjectManager)(nil).DeleteTree), ctx, spaceId, treeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockObjectManager)(nil).DeleteTree), arg0, arg1, arg2)
}
// GetObject mocks base method.
func (m *MockObjectManager) GetObject(ctx context.Context, objectId string) (syncobjectgetter.SyncObject, error) {
func (m *MockObjectManager) GetObject(arg0 context.Context, arg1 string) (syncobjectgetter.SyncObject, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetObject", ctx, objectId)
ret := m.ctrl.Call(m, "GetObject", arg0, arg1)
ret0, _ := ret[0].(syncobjectgetter.SyncObject)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetObject indicates an expected call of GetObject.
func (mr *MockObjectManagerMockRecorder) GetObject(ctx, objectId any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) GetObject(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockObjectManager)(nil).GetObject), ctx, objectId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockObjectManager)(nil).GetObject), arg0, arg1)
}
// GetTree mocks base method.
func (m *MockObjectManager) GetTree(ctx context.Context, spaceId, treeId string) (objecttree.ObjectTree, error) {
func (m *MockObjectManager) GetTree(arg0 context.Context, arg1, arg2 string) (objecttree.ObjectTree, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetTree", ctx, spaceId, treeId)
ret := m.ctrl.Call(m, "GetTree", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.ObjectTree)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetTree indicates an expected call of GetTree.
func (mr *MockObjectManagerMockRecorder) GetTree(ctx, spaceId, treeId any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) GetTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockObjectManager)(nil).GetTree), ctx, spaceId, treeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockObjectManager)(nil).GetTree), arg0, arg1, arg2)
}
// Init mocks base method.
func (m *MockObjectManager) Init(a *app.App) error {
func (m *MockObjectManager) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockObjectManagerMockRecorder) Init(a any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockObjectManager)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockObjectManager)(nil).Init), arg0)
}
// MarkTreeDeleted mocks base method.
func (m *MockObjectManager) MarkTreeDeleted(ctx context.Context, spaceId, treeId string) error {
func (m *MockObjectManager) MarkTreeDeleted(arg0 context.Context, arg1, arg2 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MarkTreeDeleted", ctx, spaceId, treeId)
ret := m.ctrl.Call(m, "MarkTreeDeleted", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// MarkTreeDeleted indicates an expected call of MarkTreeDeleted.
func (mr *MockObjectManagerMockRecorder) MarkTreeDeleted(ctx, spaceId, treeId any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) MarkTreeDeleted(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTreeDeleted", reflect.TypeOf((*MockObjectManager)(nil).MarkTreeDeleted), ctx, spaceId, treeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTreeDeleted", reflect.TypeOf((*MockObjectManager)(nil).MarkTreeDeleted), arg0, arg1, arg2)
}
// Name mocks base method.
@ -157,29 +156,29 @@ func (mr *MockObjectManagerMockRecorder) Name() *gomock.Call {
}
// Run mocks base method.
func (m *MockObjectManager) Run(ctx context.Context) error {
func (m *MockObjectManager) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockObjectManagerMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockObjectManager)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockObjectManager)(nil).Run), arg0)
}
// ValidateAndPutTree mocks base method.
func (m *MockObjectManager) ValidateAndPutTree(ctx context.Context, spaceId string, payload treestorage.TreeStorageCreatePayload) error {
func (m *MockObjectManager) ValidateAndPutTree(arg0 context.Context, arg1 string, arg2 treestorage.TreeStorageCreatePayload) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateAndPutTree", ctx, spaceId, payload)
ret := m.ctrl.Call(m, "ValidateAndPutTree", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// ValidateAndPutTree indicates an expected call of ValidateAndPutTree.
func (mr *MockObjectManagerMockRecorder) ValidateAndPutTree(ctx, spaceId, payload any) *gomock.Call {
func (mr *MockObjectManagerMockRecorder) ValidateAndPutTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAndPutTree", reflect.TypeOf((*MockObjectManager)(nil).ValidateAndPutTree), ctx, spaceId, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAndPutTree", reflect.TypeOf((*MockObjectManager)(nil).ValidateAndPutTree), arg0, arg1, arg2)
}

41
commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go
View file

@ -24,7 +24,6 @@ import (
type MockTreeBuilder struct {
ctrl *gomock.Controller
recorder *MockTreeBuilderMockRecorder
isgomock struct{}
}
// MockTreeBuilderMockRecorder is the mock recorder for MockTreeBuilder.
@ -45,76 +44,76 @@ func (m *MockTreeBuilder) EXPECT() *MockTreeBuilderMockRecorder {
}
// BuildHistoryTree mocks base method.
func (m *MockTreeBuilder) BuildHistoryTree(ctx context.Context, id string, opts objecttreebuilder.HistoryTreeOpts) (objecttree.HistoryTree, error) {
func (m *MockTreeBuilder) BuildHistoryTree(arg0 context.Context, arg1 string, arg2 objecttreebuilder.HistoryTreeOpts) (objecttree.HistoryTree, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BuildHistoryTree", ctx, id, opts)
ret := m.ctrl.Call(m, "BuildHistoryTree", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.HistoryTree)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BuildHistoryTree indicates an expected call of BuildHistoryTree.
func (mr *MockTreeBuilderMockRecorder) BuildHistoryTree(ctx, id, opts any) *gomock.Call {
func (mr *MockTreeBuilderMockRecorder) BuildHistoryTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildHistoryTree", reflect.TypeOf((*MockTreeBuilder)(nil).BuildHistoryTree), ctx, id, opts)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildHistoryTree", reflect.TypeOf((*MockTreeBuilder)(nil).BuildHistoryTree), arg0, arg1, arg2)
}
// BuildTree mocks base method.
func (m *MockTreeBuilder) BuildTree(ctx context.Context, id string, opts objecttreebuilder.BuildTreeOpts) (objecttree.ObjectTree, error) {
func (m *MockTreeBuilder) BuildTree(arg0 context.Context, arg1 string, arg2 objecttreebuilder.BuildTreeOpts) (objecttree.ObjectTree, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BuildTree", ctx, id, opts)
ret := m.ctrl.Call(m, "BuildTree", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.ObjectTree)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BuildTree indicates an expected call of BuildTree.
func (mr *MockTreeBuilderMockRecorder) BuildTree(ctx, id, opts any) *gomock.Call {
func (mr *MockTreeBuilderMockRecorder) BuildTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTree", reflect.TypeOf((*MockTreeBuilder)(nil).BuildTree), ctx, id, opts)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTree", reflect.TypeOf((*MockTreeBuilder)(nil).BuildTree), arg0, arg1, arg2)
}
// CreateTree mocks base method.
func (m *MockTreeBuilder) CreateTree(ctx context.Context, payload objecttree.ObjectTreeCreatePayload) (treestorage.TreeStorageCreatePayload, error) {
func (m *MockTreeBuilder) CreateTree(arg0 context.Context, arg1 objecttree.ObjectTreeCreatePayload) (treestorage.TreeStorageCreatePayload, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateTree", ctx, payload)
ret := m.ctrl.Call(m, "CreateTree", arg0, arg1)
ret0, _ := ret[0].(treestorage.TreeStorageCreatePayload)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateTree indicates an expected call of CreateTree.
func (mr *MockTreeBuilderMockRecorder) CreateTree(ctx, payload any) *gomock.Call {
func (mr *MockTreeBuilderMockRecorder) CreateTree(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTree", reflect.TypeOf((*MockTreeBuilder)(nil).CreateTree), ctx, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTree", reflect.TypeOf((*MockTreeBuilder)(nil).CreateTree), arg0, arg1)
}
// DeriveTree mocks base method.
func (m *MockTreeBuilder) DeriveTree(ctx context.Context, payload objecttree.ObjectTreeDerivePayload) (treestorage.TreeStorageCreatePayload, error) {
func (m *MockTreeBuilder) DeriveTree(arg0 context.Context, arg1 objecttree.ObjectTreeDerivePayload) (treestorage.TreeStorageCreatePayload, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeriveTree", ctx, payload)
ret := m.ctrl.Call(m, "DeriveTree", arg0, arg1)
ret0, _ := ret[0].(treestorage.TreeStorageCreatePayload)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeriveTree indicates an expected call of DeriveTree.
func (mr *MockTreeBuilderMockRecorder) DeriveTree(ctx, payload any) *gomock.Call {
func (mr *MockTreeBuilderMockRecorder) DeriveTree(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveTree", reflect.TypeOf((*MockTreeBuilder)(nil).DeriveTree), ctx, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveTree", reflect.TypeOf((*MockTreeBuilder)(nil).DeriveTree), arg0, arg1)
}
// PutTree mocks base method.
func (m *MockTreeBuilder) PutTree(ctx context.Context, payload treestorage.TreeStorageCreatePayload, listener updatelistener.UpdateListener) (objecttree.ObjectTree, error) {
func (m *MockTreeBuilder) PutTree(arg0 context.Context, arg1 treestorage.TreeStorageCreatePayload, arg2 updatelistener.UpdateListener) (objecttree.ObjectTree, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutTree", ctx, payload, listener)
ret := m.ctrl.Call(m, "PutTree", arg0, arg1, arg2)
ret0, _ := ret[0].(objecttree.ObjectTree)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PutTree indicates an expected call of PutTree.
func (mr *MockTreeBuilderMockRecorder) PutTree(ctx, payload, listener any) *gomock.Call {
func (mr *MockTreeBuilderMockRecorder) PutTree(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTree", reflect.TypeOf((*MockTreeBuilder)(nil).PutTree), ctx, payload, listener)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTree", reflect.TypeOf((*MockTreeBuilder)(nil).PutTree), arg0, arg1, arg2)
}

49
commonspace/peermanager/mock_peermanager/mock_peermanager.go
View file

@ -23,7 +23,6 @@ import (
type MockPeerManager struct {
ctrl *gomock.Controller
recorder *MockPeerManagerMockRecorder
isgomock struct{}
}
// MockPeerManagerMockRecorder is the mock recorder for MockPeerManager.
@ -44,73 +43,73 @@ func (m *MockPeerManager) EXPECT() *MockPeerManagerMockRecorder {
}
// BroadcastMessage mocks base method.
func (m *MockPeerManager) BroadcastMessage(ctx context.Context, msg drpc.Message) error {
func (m *MockPeerManager) BroadcastMessage(arg0 context.Context, arg1 drpc.Message) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BroadcastMessage", ctx, msg)
ret := m.ctrl.Call(m, "BroadcastMessage", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// BroadcastMessage indicates an expected call of BroadcastMessage.
func (mr *MockPeerManagerMockRecorder) BroadcastMessage(ctx, msg any) *gomock.Call {
func (mr *MockPeerManagerMockRecorder) BroadcastMessage(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastMessage", reflect.TypeOf((*MockPeerManager)(nil).BroadcastMessage), ctx, msg)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastMessage", reflect.TypeOf((*MockPeerManager)(nil).BroadcastMessage), arg0, arg1)
}
// GetNodePeers mocks base method.
func (m *MockPeerManager) GetNodePeers(ctx context.Context) ([]peer.Peer, error) {
func (m *MockPeerManager) GetNodePeers(arg0 context.Context) ([]peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNodePeers", ctx)
ret := m.ctrl.Call(m, "GetNodePeers", arg0)
ret0, _ := ret[0].([]peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNodePeers indicates an expected call of GetNodePeers.
func (mr *MockPeerManagerMockRecorder) GetNodePeers(ctx any) *gomock.Call {
func (mr *MockPeerManagerMockRecorder) GetNodePeers(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePeers", reflect.TypeOf((*MockPeerManager)(nil).GetNodePeers), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePeers", reflect.TypeOf((*MockPeerManager)(nil).GetNodePeers), arg0)
}
// GetResponsiblePeers mocks base method.
func (m *MockPeerManager) GetResponsiblePeers(ctx context.Context) ([]peer.Peer, error) {
func (m *MockPeerManager) GetResponsiblePeers(arg0 context.Context) ([]peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetResponsiblePeers", ctx)
ret := m.ctrl.Call(m, "GetResponsiblePeers", arg0)
ret0, _ := ret[0].([]peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetResponsiblePeers indicates an expected call of GetResponsiblePeers.
func (mr *MockPeerManagerMockRecorder) GetResponsiblePeers(ctx any) *gomock.Call {
func (mr *MockPeerManagerMockRecorder) GetResponsiblePeers(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResponsiblePeers", reflect.TypeOf((*MockPeerManager)(nil).GetResponsiblePeers), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResponsiblePeers", reflect.TypeOf((*MockPeerManager)(nil).GetResponsiblePeers), arg0)
}
// Init mocks base method.
func (m *MockPeerManager) Init(a *app.App) error {
func (m *MockPeerManager) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockPeerManagerMockRecorder) Init(a any) *gomock.Call {
func (mr *MockPeerManagerMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockPeerManager)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockPeerManager)(nil).Init), arg0)
}
// KeepAlive mocks base method.
func (m *MockPeerManager) KeepAlive(ctx context.Context) {
func (m *MockPeerManager) KeepAlive(arg0 context.Context) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "KeepAlive", ctx)
m.ctrl.Call(m, "KeepAlive", arg0)
}
// KeepAlive indicates an expected call of KeepAlive.
func (mr *MockPeerManagerMockRecorder) KeepAlive(ctx any) *gomock.Call {
func (mr *MockPeerManagerMockRecorder) KeepAlive(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeepAlive", reflect.TypeOf((*MockPeerManager)(nil).KeepAlive), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeepAlive", reflect.TypeOf((*MockPeerManager)(nil).KeepAlive), arg0)
}
// Name mocks base method.
@ -128,15 +127,15 @@ func (mr *MockPeerManagerMockRecorder) Name() *gomock.Call {
}
// SendMessage mocks base method.
func (m *MockPeerManager) SendMessage(ctx context.Context, peerId string, msg drpc.Message) error {
func (m *MockPeerManager) SendMessage(arg0 context.Context, arg1 string, arg2 drpc.Message) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendMessage", ctx, peerId, msg)
ret := m.ctrl.Call(m, "SendMessage", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// SendMessage indicates an expected call of SendMessage.
func (mr *MockPeerManagerMockRecorder) SendMessage(ctx, peerId, msg any) *gomock.Call {
func (mr *MockPeerManagerMockRecorder) SendMessage(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockPeerManager)(nil).SendMessage), ctx, peerId, msg)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockPeerManager)(nil).SendMessage), arg0, arg1, arg2)
}

18
commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go
View file

@ -21,7 +21,6 @@ import (
type MockStateBuilder struct {
ctrl *gomock.Controller
recorder *MockStateBuilderMockRecorder
isgomock struct{}
}
// MockStateBuilderMockRecorder is the mock recorder for MockStateBuilder.
@ -42,25 +41,24 @@ func (m *MockStateBuilder) EXPECT() *MockStateBuilderMockRecorder {
}
// Build mocks base method.
func (m *MockStateBuilder) Build(tree objecttree.ReadableObjectTree, state *settingsstate.State) (*settingsstate.State, error) {
func (m *MockStateBuilder) Build(arg0 objecttree.ReadableObjectTree, arg1 *settingsstate.State) (*settingsstate.State, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Build", tree, state)
ret := m.ctrl.Call(m, "Build", arg0, arg1)
ret0, _ := ret[0].(*settingsstate.State)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Build indicates an expected call of Build.
func (mr *MockStateBuilderMockRecorder) Build(tree, state any) *gomock.Call {
func (mr *MockStateBuilderMockRecorder) Build(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockStateBuilder)(nil).Build), tree, state)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockStateBuilder)(nil).Build), arg0, arg1)
}
// MockChangeFactory is a mock of ChangeFactory interface.
type MockChangeFactory struct {
ctrl *gomock.Controller
recorder *MockChangeFactoryMockRecorder
isgomock struct{}
}
// MockChangeFactoryMockRecorder is the mock recorder for MockChangeFactory.
@ -81,16 +79,16 @@ func (m *MockChangeFactory) EXPECT() *MockChangeFactoryMockRecorder {
}
// CreateObjectDeleteChange mocks base method.
func (m *MockChangeFactory) CreateObjectDeleteChange(id string, state *settingsstate.State, isSnapshot bool) ([]byte, error) {
func (m *MockChangeFactory) CreateObjectDeleteChange(arg0 string, arg1 *settingsstate.State, arg2 bool) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateObjectDeleteChange", id, state, isSnapshot)
ret := m.ctrl.Call(m, "CreateObjectDeleteChange", arg0, arg1, arg2)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateObjectDeleteChange indicates an expected call of CreateObjectDeleteChange.
func (mr *MockChangeFactoryMockRecorder) CreateObjectDeleteChange(id, state, isSnapshot any) *gomock.Call {
func (mr *MockChangeFactoryMockRecorder) CreateObjectDeleteChange(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateObjectDeleteChange", reflect.TypeOf((*MockChangeFactory)(nil).CreateObjectDeleteChange), id, state, isSnapshot)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateObjectDeleteChange", reflect.TypeOf((*MockChangeFactory)(nil).CreateObjectDeleteChange), arg0, arg1, arg2)
}

91
commonspace/spacestorage/migration/executor_test.go Normal file
View file

@ -0,0 +1,91 @@
package migration
import (
"context"
"sync"
"testing"
"github.com/stretchr/testify/require"
)
func TestMigratePoolBasicFunctionality(t *testing.T) {
ctx := context.Background()
pool := newMigratePool(ctx, 2, 10)
pool.Run()
var (
mu sync.Mutex
count int
wg sync.WaitGroup
nTasks = 5
)
wg.Add(nTasks)
for i := 0; i < nTasks; i++ {
err := pool.Add(ctx, func() {
mu.Lock()
count++
mu.Unlock()
wg.Done()
})
require.NoError(t, err)
}
wg.Wait()
require.NoError(t, pool.Wait())
require.Equal(t, nTasks, count)
}
func TestMigratePoolContextCancel(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
pool := newMigratePool(ctx, 1, 1)
pool.Run()
taskStarted := make(chan struct{})
testProceed := make(chan struct{})
err := pool.Add(ctx, func() {
close(taskStarted)
<-testProceed
})
require.NoError(t, err)
<-taskStarted
cancel()
require.Error(t, pool.Wait())
close(testProceed)
}
func TestMigratePoolTryAddWhenFull(t *testing.T) {
ctx := context.Background()
pool := newMigratePool(ctx, 1, 1)
pool.Run()
block := make(chan struct{})
defer close(block)
err := pool.TryAdd(func() {
<-block
})
require.NoError(t, err)
require.Error(t, pool.TryAdd(func() {}))
}
func TestContextWaitGroupNormalWait(t *testing.T) {
ctx := context.Background()
cwg := newContextWaitGroup(ctx)
var wg sync.WaitGroup
wg.Add(2)
cwg.Add(2)
go func() {
defer wg.Done()
cwg.Done()
}()
go func() {
defer wg.Done()
cwg.Done()
}()
wg.Wait()
require.NoError(t, cwg.Wait())
}
func TestContextWaitGroupContextCancel(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cwg := newContextWaitGroup(ctx)
cwg.Add(1)
cancel()
require.Error(t, cwg.Wait())
}

235
commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
View file

@ -13,10 +13,13 @@ import (
context "context"
reflect "reflect"
anystore "github.com/anyproto/any-store"
app "github.com/anyproto/any-sync/app"
treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
headstorage "github.com/anyproto/any-sync/commonspace/headsync/headstorage"
statestorage "github.com/anyproto/any-sync/commonspace/headsync/statestorage"
list "github.com/anyproto/any-sync/commonspace/object/acl/list"
objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
gomock "go.uber.org/mock/gomock"
)
@ -24,7 +27,6 @@ import (
type MockSpaceStorage struct {
ctrl *gomock.Controller
recorder *MockSpaceStorageMockRecorder
isgomock struct{}
}
// MockSpaceStorageMockRecorder is the mock recorder for MockSpaceStorage.
@ -45,10 +47,10 @@ func (m *MockSpaceStorage) EXPECT() *MockSpaceStorageMockRecorder {
}
// AclStorage mocks base method.
func (m *MockSpaceStorage) AclStorage() (liststorage.ListStorage, error) {
func (m *MockSpaceStorage) AclStorage() (list.Storage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclStorage")
ret0, _ := ret[0].(liststorage.ListStorage)
ret0, _ := ret[0].(list.Storage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -59,48 +61,61 @@ func (mr *MockSpaceStorageMockRecorder) AclStorage() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclStorage", reflect.TypeOf((*MockSpaceStorage)(nil).AclStorage))
}
// Close mocks base method.
func (m *MockSpaceStorage) Close(ctx context.Context) error {
// AnyStore mocks base method.
func (m *MockSpaceStorage) AnyStore() anystore.DB {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "AnyStore")
ret0, _ := ret[0].(anystore.DB)
return ret0
}
// AnyStore indicates an expected call of AnyStore.
func (mr *MockSpaceStorageMockRecorder) AnyStore() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnyStore", reflect.TypeOf((*MockSpaceStorage)(nil).AnyStore))
}
// Close mocks base method.
func (m *MockSpaceStorage) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockSpaceStorageMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceStorage)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceStorage)(nil).Close), arg0)
}
// CreateTreeStorage mocks base method.
func (m *MockSpaceStorage) CreateTreeStorage(payload treestorage.TreeStorageCreatePayload) (treestorage.TreeStorage, error) {
func (m *MockSpaceStorage) CreateTreeStorage(arg0 context.Context, arg1 treestorage.TreeStorageCreatePayload) (objecttree.Storage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateTreeStorage", payload)
ret0, _ := ret[0].(treestorage.TreeStorage)
ret := m.ctrl.Call(m, "CreateTreeStorage", arg0, arg1)
ret0, _ := ret[0].(objecttree.Storage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateTreeStorage indicates an expected call of CreateTreeStorage.
func (mr *MockSpaceStorageMockRecorder) CreateTreeStorage(payload any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) CreateTreeStorage(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).CreateTreeStorage), payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).CreateTreeStorage), arg0, arg1)
}
// HasTree mocks base method.
func (m *MockSpaceStorage) HasTree(id string) (bool, error) {
// HeadStorage mocks base method.
func (m *MockSpaceStorage) HeadStorage() headstorage.HeadStorage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasTree", id)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
ret := m.ctrl.Call(m, "HeadStorage")
ret0, _ := ret[0].(headstorage.HeadStorage)
return ret0
}
// HasTree indicates an expected call of HasTree.
func (mr *MockSpaceStorageMockRecorder) HasTree(id any) *gomock.Call {
// HeadStorage indicates an expected call of HeadStorage.
func (mr *MockSpaceStorageMockRecorder) HeadStorage() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasTree", reflect.TypeOf((*MockSpaceStorage)(nil).HasTree), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadStorage", reflect.TypeOf((*MockSpaceStorage)(nil).HeadStorage))
}
// Id mocks base method.
@ -118,32 +133,17 @@ func (mr *MockSpaceStorageMockRecorder) Id() *gomock.Call {
}
// Init mocks base method.
func (m *MockSpaceStorage) Init(a *app.App) error {
func (m *MockSpaceStorage) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockSpaceStorageMockRecorder) Init(a any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceStorage)(nil).Init), a)
}
// IsSpaceDeleted mocks base method.
func (m *MockSpaceStorage) IsSpaceDeleted() (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsSpaceDeleted")
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsSpaceDeleted indicates an expected call of IsSpaceDeleted.
func (mr *MockSpaceStorageMockRecorder) IsSpaceDeleted() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSpaceDeleted", reflect.TypeOf((*MockSpaceStorage)(nil).IsSpaceDeleted))
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceStorage)(nil).Init), arg0)
}
// Name mocks base method.
@ -160,162 +160,45 @@ func (mr *MockSpaceStorageMockRecorder) Name() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockSpaceStorage)(nil).Name))
}
// ReadSpaceHash mocks base method.
func (m *MockSpaceStorage) ReadSpaceHash() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReadSpaceHash")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReadSpaceHash indicates an expected call of ReadSpaceHash.
func (mr *MockSpaceStorageMockRecorder) ReadSpaceHash() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSpaceHash", reflect.TypeOf((*MockSpaceStorage)(nil).ReadSpaceHash))
}
// Run mocks base method.
func (m *MockSpaceStorage) Run(ctx context.Context) error {
func (m *MockSpaceStorage) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockSpaceStorageMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSpaceStorage)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSpaceStorage)(nil).Run), arg0)
}
// SetSpaceDeleted mocks base method.
func (m *MockSpaceStorage) SetSpaceDeleted() error {
// StateStorage mocks base method.
func (m *MockSpaceStorage) StateStorage() statestorage.StateStorage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetSpaceDeleted")
ret0, _ := ret[0].(error)
ret := m.ctrl.Call(m, "StateStorage")
ret0, _ := ret[0].(statestorage.StateStorage)
return ret0
}
// SetSpaceDeleted indicates an expected call of SetSpaceDeleted.
func (mr *MockSpaceStorageMockRecorder) SetSpaceDeleted() *gomock.Call {
// StateStorage indicates an expected call of StateStorage.
func (mr *MockSpaceStorageMockRecorder) StateStorage() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSpaceDeleted", reflect.TypeOf((*MockSpaceStorage)(nil).SetSpaceDeleted))
}
// SetTreeDeletedStatus mocks base method.
func (m *MockSpaceStorage) SetTreeDeletedStatus(id, state string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetTreeDeletedStatus", id, state)
ret0, _ := ret[0].(error)
return ret0
}
// SetTreeDeletedStatus indicates an expected call of SetTreeDeletedStatus.
func (mr *MockSpaceStorageMockRecorder) SetTreeDeletedStatus(id, state any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTreeDeletedStatus", reflect.TypeOf((*MockSpaceStorage)(nil).SetTreeDeletedStatus), id, state)
}
// SpaceHeader mocks base method.
func (m *MockSpaceStorage) SpaceHeader() (*spacesyncproto.RawSpaceHeaderWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceHeader")
ret0, _ := ret[0].(*spacesyncproto.RawSpaceHeaderWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SpaceHeader indicates an expected call of SpaceHeader.
func (mr *MockSpaceStorageMockRecorder) SpaceHeader() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceHeader", reflect.TypeOf((*MockSpaceStorage)(nil).SpaceHeader))
}
// SpaceSettingsId mocks base method.
func (m *MockSpaceStorage) SpaceSettingsId() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceSettingsId")
ret0, _ := ret[0].(string)
return ret0
}
// SpaceSettingsId indicates an expected call of SpaceSettingsId.
func (mr *MockSpaceStorageMockRecorder) SpaceSettingsId() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceSettingsId", reflect.TypeOf((*MockSpaceStorage)(nil).SpaceSettingsId))
}
// StoredIds mocks base method.
func (m *MockSpaceStorage) StoredIds() ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StoredIds")
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StoredIds indicates an expected call of StoredIds.
func (mr *MockSpaceStorageMockRecorder) StoredIds() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoredIds", reflect.TypeOf((*MockSpaceStorage)(nil).StoredIds))
}
// TreeDeletedStatus mocks base method.
func (m *MockSpaceStorage) TreeDeletedStatus(id string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TreeDeletedStatus", id)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TreeDeletedStatus indicates an expected call of TreeDeletedStatus.
func (mr *MockSpaceStorageMockRecorder) TreeDeletedStatus(id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeDeletedStatus", reflect.TypeOf((*MockSpaceStorage)(nil).TreeDeletedStatus), id)
}
// TreeRoot mocks base method.
func (m *MockSpaceStorage) TreeRoot(id string) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TreeRoot", id)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TreeRoot indicates an expected call of TreeRoot.
func (mr *MockSpaceStorageMockRecorder) TreeRoot(id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeRoot", reflect.TypeOf((*MockSpaceStorage)(nil).TreeRoot), id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateStorage", reflect.TypeOf((*MockSpaceStorage)(nil).StateStorage))
}
// TreeStorage mocks base method.
func (m *MockSpaceStorage) TreeStorage(id string) (treestorage.TreeStorage, error) {
func (m *MockSpaceStorage) TreeStorage(arg0 context.Context, arg1 string) (objecttree.Storage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TreeStorage", id)
ret0, _ := ret[0].(treestorage.TreeStorage)
ret := m.ctrl.Call(m, "TreeStorage", arg0, arg1)
ret0, _ := ret[0].(objecttree.Storage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TreeStorage indicates an expected call of TreeStorage.
func (mr *MockSpaceStorageMockRecorder) TreeStorage(id any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) TreeStorage(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).TreeStorage), id)
}
// WriteSpaceHash mocks base method.
func (m *MockSpaceStorage) WriteSpaceHash(hash string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WriteSpaceHash", hash)
ret0, _ := ret[0].(error)
return ret0
}
// WriteSpaceHash indicates an expected call of WriteSpaceHash.
func (mr *MockSpaceStorageMockRecorder) WriteSpaceHash(hash any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteSpaceHash", reflect.TypeOf((*MockSpaceStorage)(nil).WriteSpaceHash), hash)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).TreeStorage), arg0, arg1)
}

65
commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go
View file

@ -22,7 +22,6 @@ import (
type MockDRPCSpaceSyncClient struct {
ctrl *gomock.Controller
recorder *MockDRPCSpaceSyncClientMockRecorder
isgomock struct{}
}
// MockDRPCSpaceSyncClientMockRecorder is the mock recorder for MockDRPCSpaceSyncClient.
@ -43,33 +42,33 @@ func (m *MockDRPCSpaceSyncClient) EXPECT() *MockDRPCSpaceSyncClientMockRecorder
}
// AclAddRecord mocks base method.
func (m *MockDRPCSpaceSyncClient) AclAddRecord(ctx context.Context, in *spacesyncproto.AclAddRecordRequest) (*spacesyncproto.AclAddRecordResponse, error) {
func (m *MockDRPCSpaceSyncClient) AclAddRecord(arg0 context.Context, arg1 *spacesyncproto.AclAddRecordRequest) (*spacesyncproto.AclAddRecordResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclAddRecord", ctx, in)
ret := m.ctrl.Call(m, "AclAddRecord", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.AclAddRecordResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclAddRecord indicates an expected call of AclAddRecord.
func (mr *MockDRPCSpaceSyncClientMockRecorder) AclAddRecord(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) AclAddRecord(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclAddRecord", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).AclAddRecord), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclAddRecord", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).AclAddRecord), arg0, arg1)
}
// AclGetRecords mocks base method.
func (m *MockDRPCSpaceSyncClient) AclGetRecords(ctx context.Context, in *spacesyncproto.AclGetRecordsRequest) (*spacesyncproto.AclGetRecordsResponse, error) {
func (m *MockDRPCSpaceSyncClient) AclGetRecords(arg0 context.Context, arg1 *spacesyncproto.AclGetRecordsRequest) (*spacesyncproto.AclGetRecordsResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclGetRecords", ctx, in)
ret := m.ctrl.Call(m, "AclGetRecords", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.AclGetRecordsResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclGetRecords indicates an expected call of AclGetRecords.
func (mr *MockDRPCSpaceSyncClientMockRecorder) AclGetRecords(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) AclGetRecords(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).AclGetRecords), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).AclGetRecords), arg0, arg1)
}
// DRPCConn mocks base method.
@ -87,91 +86,91 @@ func (mr *MockDRPCSpaceSyncClientMockRecorder) DRPCConn() *gomock.Call {
}
// HeadSync mocks base method.
func (m *MockDRPCSpaceSyncClient) HeadSync(ctx context.Context, in *spacesyncproto.HeadSyncRequest) (*spacesyncproto.HeadSyncResponse, error) {
func (m *MockDRPCSpaceSyncClient) HeadSync(arg0 context.Context, arg1 *spacesyncproto.HeadSyncRequest) (*spacesyncproto.HeadSyncResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HeadSync", ctx, in)
ret := m.ctrl.Call(m, "HeadSync", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.HeadSyncResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HeadSync indicates an expected call of HeadSync.
func (mr *MockDRPCSpaceSyncClientMockRecorder) HeadSync(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) HeadSync(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadSync", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).HeadSync), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadSync", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).HeadSync), arg0, arg1)
}
// ObjectSync mocks base method.
func (m *MockDRPCSpaceSyncClient) ObjectSync(ctx context.Context, in *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
func (m *MockDRPCSpaceSyncClient) ObjectSync(arg0 context.Context, arg1 *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ObjectSync", ctx, in)
ret := m.ctrl.Call(m, "ObjectSync", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ObjectSync indicates an expected call of ObjectSync.
func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSync(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSync(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSync", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSync), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSync", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSync), arg0, arg1)
}
// ObjectSyncRequestStream mocks base method.
func (m *MockDRPCSpaceSyncClient) ObjectSyncRequestStream(ctx context.Context, in *spacesyncproto.ObjectSyncMessage) (spacesyncproto.DRPCSpaceSync_ObjectSyncRequestStreamClient, error) {
func (m *MockDRPCSpaceSyncClient) ObjectSyncRequestStream(arg0 context.Context, arg1 *spacesyncproto.ObjectSyncMessage) (spacesyncproto.DRPCSpaceSync_ObjectSyncRequestStreamClient, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ObjectSyncRequestStream", ctx, in)
ret := m.ctrl.Call(m, "ObjectSyncRequestStream", arg0, arg1)
ret0, _ := ret[0].(spacesyncproto.DRPCSpaceSync_ObjectSyncRequestStreamClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ObjectSyncRequestStream indicates an expected call of ObjectSyncRequestStream.
func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSyncRequestStream(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSyncRequestStream(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSyncRequestStream", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSyncRequestStream), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSyncRequestStream", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSyncRequestStream), arg0, arg1)
}
// ObjectSyncStream mocks base method.
func (m *MockDRPCSpaceSyncClient) ObjectSyncStream(ctx context.Context) (spacesyncproto.DRPCSpaceSync_ObjectSyncStreamClient, error) {
func (m *MockDRPCSpaceSyncClient) ObjectSyncStream(arg0 context.Context) (spacesyncproto.DRPCSpaceSync_ObjectSyncStreamClient, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ObjectSyncStream", ctx)
ret := m.ctrl.Call(m, "ObjectSyncStream", arg0)
ret0, _ := ret[0].(spacesyncproto.DRPCSpaceSync_ObjectSyncStreamClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ObjectSyncStream indicates an expected call of ObjectSyncStream.
func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSyncStream(ctx any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSyncStream(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSyncStream", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSyncStream), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSyncStream", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSyncStream), arg0)
}
// SpacePull mocks base method.
func (m *MockDRPCSpaceSyncClient) SpacePull(ctx context.Context, in *spacesyncproto.SpacePullRequest) (*spacesyncproto.SpacePullResponse, error) {
func (m *MockDRPCSpaceSyncClient) SpacePull(arg0 context.Context, arg1 *spacesyncproto.SpacePullRequest) (*spacesyncproto.SpacePullResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpacePull", ctx, in)
ret := m.ctrl.Call(m, "SpacePull", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.SpacePullResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SpacePull indicates an expected call of SpacePull.
func (mr *MockDRPCSpaceSyncClientMockRecorder) SpacePull(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) SpacePull(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacePull", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).SpacePull), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacePull", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).SpacePull), arg0, arg1)
}
// SpacePush mocks base method.
func (m *MockDRPCSpaceSyncClient) SpacePush(ctx context.Context, in *spacesyncproto.SpacePushRequest) (*spacesyncproto.SpacePushResponse, error) {
func (m *MockDRPCSpaceSyncClient) SpacePush(arg0 context.Context, arg1 *spacesyncproto.SpacePushRequest) (*spacesyncproto.SpacePushResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpacePush", ctx, in)
ret := m.ctrl.Call(m, "SpacePush", arg0, arg1)
ret0, _ := ret[0].(*spacesyncproto.SpacePushResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SpacePush indicates an expected call of SpacePush.
func (mr *MockDRPCSpaceSyncClientMockRecorder) SpacePush(ctx, in any) *gomock.Call {
func (mr *MockDRPCSpaceSyncClientMockRecorder) SpacePush(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacePush", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).SpacePush), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacePush", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).SpacePush), arg0, arg1)
}

59
commonspace/sync/syncdeps/mock_syncdeps/mock_syncdeps.go
View file

@ -13,7 +13,6 @@ import (
context "context"
reflect "reflect"
spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
syncdeps "github.com/anyproto/any-sync/commonspace/sync/syncdeps"
syncstatus "github.com/anyproto/any-sync/commonspace/syncstatus"
proto "github.com/anyproto/protobuf/proto"
@ -25,7 +24,6 @@ import (
type MockObjectSyncHandler struct {
ctrl *gomock.Controller
recorder *MockObjectSyncHandlerMockRecorder
isgomock struct{}
}
// MockObjectSyncHandlerMockRecorder is the mock recorder for MockObjectSyncHandler.
@ -45,63 +43,48 @@ func (m *MockObjectSyncHandler) EXPECT() *MockObjectSyncHandlerMockRecorder {
return m.recorder
}
// HandleDeprecatedRequest mocks base method.
func (m *MockObjectSyncHandler) HandleDeprecatedRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleDeprecatedRequest", ctx, req)
ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleDeprecatedRequest indicates an expected call of HandleDeprecatedRequest.
func (mr *MockObjectSyncHandlerMockRecorder) HandleDeprecatedRequest(ctx, req any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDeprecatedRequest", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleDeprecatedRequest), ctx, req)
}
// HandleHeadUpdate mocks base method.
func (m *MockObjectSyncHandler) HandleHeadUpdate(ctx context.Context, statusUpdater syncstatus.StatusUpdater, headUpdate drpc.Message) (syncdeps.Request, error) {
func (m *MockObjectSyncHandler) HandleHeadUpdate(arg0 context.Context, arg1 syncstatus.StatusUpdater, arg2 drpc.Message) (syncdeps.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleHeadUpdate", ctx, statusUpdater, headUpdate)
ret := m.ctrl.Call(m, "HandleHeadUpdate", arg0, arg1, arg2)
ret0, _ := ret[0].(syncdeps.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleHeadUpdate indicates an expected call of HandleHeadUpdate.
func (mr *MockObjectSyncHandlerMockRecorder) HandleHeadUpdate(ctx, statusUpdater, headUpdate any) *gomock.Call {
func (mr *MockObjectSyncHandlerMockRecorder) HandleHeadUpdate(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleHeadUpdate), ctx, statusUpdater, headUpdate)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleHeadUpdate), arg0, arg1, arg2)
}
// HandleResponse mocks base method.
func (m *MockObjectSyncHandler) HandleResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
func (m *MockObjectSyncHandler) HandleResponse(arg0 context.Context, arg1, arg2 string, arg3 syncdeps.Response) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleResponse", ctx, peerId, objectId, resp)
ret := m.ctrl.Call(m, "HandleResponse", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// HandleResponse indicates an expected call of HandleResponse.
func (mr *MockObjectSyncHandlerMockRecorder) HandleResponse(ctx, peerId, objectId, resp any) *gomock.Call {
func (mr *MockObjectSyncHandlerMockRecorder) HandleResponse(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleResponse), ctx, peerId, objectId, resp)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleResponse), arg0, arg1, arg2, arg3)
}
// HandleStreamRequest mocks base method.
func (m *MockObjectSyncHandler) HandleStreamRequest(ctx context.Context, rq syncdeps.Request, updater syncdeps.QueueSizeUpdater, send func(proto.Message) error) (syncdeps.Request, error) {
func (m *MockObjectSyncHandler) HandleStreamRequest(arg0 context.Context, arg1 syncdeps.Request, arg2 syncdeps.QueueSizeUpdater, arg3 func(proto.Message) error) (syncdeps.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HandleStreamRequest", ctx, rq, updater, send)
ret := m.ctrl.Call(m, "HandleStreamRequest", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(syncdeps.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HandleStreamRequest indicates an expected call of HandleStreamRequest.
func (mr *MockObjectSyncHandlerMockRecorder) HandleStreamRequest(ctx, rq, updater, send any) *gomock.Call {
func (mr *MockObjectSyncHandlerMockRecorder) HandleStreamRequest(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleStreamRequest), ctx, rq, updater, send)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockObjectSyncHandler)(nil).HandleStreamRequest), arg0, arg1, arg2, arg3)
}
// ResponseCollector mocks base method.
@ -122,7 +105,6 @@ func (mr *MockObjectSyncHandlerMockRecorder) ResponseCollector() *gomock.Call {
type MockRequestSender struct {
ctrl *gomock.Controller
recorder *MockRequestSenderMockRecorder
isgomock struct{}
}
// MockRequestSenderMockRecorder is the mock recorder for MockRequestSender.
@ -143,24 +125,23 @@ func (m *MockRequestSender) EXPECT() *MockRequestSenderMockRecorder {
}
// SendRequest mocks base method.
func (m *MockRequestSender) SendRequest(ctx context.Context, rq syncdeps.Request, collector syncdeps.ResponseCollector) error {
func (m *MockRequestSender) SendRequest(arg0 context.Context, arg1 syncdeps.Request, arg2 syncdeps.ResponseCollector) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendRequest", ctx, rq, collector)
ret := m.ctrl.Call(m, "SendRequest", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// SendRequest indicates an expected call of SendRequest.
func (mr *MockRequestSenderMockRecorder) SendRequest(ctx, rq, collector any) *gomock.Call {
func (mr *MockRequestSenderMockRecorder) SendRequest(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockRequestSender)(nil).SendRequest), ctx, rq, collector)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockRequestSender)(nil).SendRequest), arg0, arg1, arg2)
}
// MockResponseCollector is a mock of ResponseCollector interface.
type MockResponseCollector struct {
ctrl *gomock.Controller
recorder *MockResponseCollectorMockRecorder
isgomock struct{}
}
// MockResponseCollectorMockRecorder is the mock recorder for MockResponseCollector.
@ -181,17 +162,17 @@ func (m *MockResponseCollector) EXPECT() *MockResponseCollectorMockRecorder {
}
// CollectResponse mocks base method.
func (m *MockResponseCollector) CollectResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
func (m *MockResponseCollector) CollectResponse(arg0 context.Context, arg1, arg2 string, arg3 syncdeps.Response) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CollectResponse", ctx, peerId, objectId, resp)
ret := m.ctrl.Call(m, "CollectResponse", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
}
// CollectResponse indicates an expected call of CollectResponse.
func (mr *MockResponseCollectorMockRecorder) CollectResponse(ctx, peerId, objectId, resp any) *gomock.Call {
func (mr *MockResponseCollectorMockRecorder) CollectResponse(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectResponse", reflect.TypeOf((*MockResponseCollector)(nil).CollectResponse), ctx, peerId, objectId, resp)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectResponse", reflect.TypeOf((*MockResponseCollector)(nil).CollectResponse), arg0, arg1, arg2, arg3)
}
// NewResponse mocks base method.

41
commonspace/syncstatus/mock_syncstatus/mock_syncstatus.go
View file

@ -20,7 +20,6 @@ import (
type MockStatusUpdater struct {
ctrl *gomock.Controller
recorder *MockStatusUpdaterMockRecorder
isgomock struct{}
}
// MockStatusUpdaterMockRecorder is the mock recorder for MockStatusUpdater.
@ -41,53 +40,53 @@ func (m *MockStatusUpdater) EXPECT() *MockStatusUpdaterMockRecorder {
}
// HeadsApply mocks base method.
func (m *MockStatusUpdater) HeadsApply(senderId, treeId string, heads []string, allAdded bool) {
func (m *MockStatusUpdater) HeadsApply(arg0, arg1 string, arg2 []string, arg3 bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "HeadsApply", senderId, treeId, heads, allAdded)
m.ctrl.Call(m, "HeadsApply", arg0, arg1, arg2, arg3)
}
// HeadsApply indicates an expected call of HeadsApply.
func (mr *MockStatusUpdaterMockRecorder) HeadsApply(senderId, treeId, heads, allAdded any) *gomock.Call {
func (mr *MockStatusUpdaterMockRecorder) HeadsApply(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadsApply", reflect.TypeOf((*MockStatusUpdater)(nil).HeadsApply), senderId, treeId, heads, allAdded)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadsApply", reflect.TypeOf((*MockStatusUpdater)(nil).HeadsApply), arg0, arg1, arg2, arg3)
}
// HeadsChange mocks base method.
func (m *MockStatusUpdater) HeadsChange(treeId string, heads []string) {
func (m *MockStatusUpdater) HeadsChange(arg0 string, arg1 []string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "HeadsChange", treeId, heads)
m.ctrl.Call(m, "HeadsChange", arg0, arg1)
}
// HeadsChange indicates an expected call of HeadsChange.
func (mr *MockStatusUpdaterMockRecorder) HeadsChange(treeId, heads any) *gomock.Call {
func (mr *MockStatusUpdaterMockRecorder) HeadsChange(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadsChange", reflect.TypeOf((*MockStatusUpdater)(nil).HeadsChange), treeId, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadsChange", reflect.TypeOf((*MockStatusUpdater)(nil).HeadsChange), arg0, arg1)
}
// HeadsReceive mocks base method.
func (m *MockStatusUpdater) HeadsReceive(senderId, treeId string, heads []string) {
func (m *MockStatusUpdater) HeadsReceive(arg0, arg1 string, arg2 []string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "HeadsReceive", senderId, treeId, heads)
m.ctrl.Call(m, "HeadsReceive", arg0, arg1, arg2)
}
// HeadsReceive indicates an expected call of HeadsReceive.
func (mr *MockStatusUpdaterMockRecorder) HeadsReceive(senderId, treeId, heads any) *gomock.Call {
func (mr *MockStatusUpdaterMockRecorder) HeadsReceive(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadsReceive", reflect.TypeOf((*MockStatusUpdater)(nil).HeadsReceive), senderId, treeId, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadsReceive", reflect.TypeOf((*MockStatusUpdater)(nil).HeadsReceive), arg0, arg1, arg2)
}
// Init mocks base method.
func (m *MockStatusUpdater) Init(a *app.App) error {
func (m *MockStatusUpdater) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockStatusUpdaterMockRecorder) Init(a any) *gomock.Call {
func (mr *MockStatusUpdaterMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockStatusUpdater)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockStatusUpdater)(nil).Init), arg0)
}
// Name mocks base method.
@ -105,13 +104,13 @@ func (mr *MockStatusUpdaterMockRecorder) Name() *gomock.Call {
}
// ObjectReceive mocks base method.
func (m *MockStatusUpdater) ObjectReceive(senderId, treeId string, heads []string) {
func (m *MockStatusUpdater) ObjectReceive(arg0, arg1 string, arg2 []string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ObjectReceive", senderId, treeId, heads)
m.ctrl.Call(m, "ObjectReceive", arg0, arg1, arg2)
}
// ObjectReceive indicates an expected call of ObjectReceive.
func (mr *MockStatusUpdaterMockRecorder) ObjectReceive(senderId, treeId, heads any) *gomock.Call {
func (mr *MockStatusUpdaterMockRecorder) ObjectReceive(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectReceive", reflect.TypeOf((*MockStatusUpdater)(nil).ObjectReceive), senderId, treeId, heads)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectReceive", reflect.TypeOf((*MockStatusUpdater)(nil).ObjectReceive), arg0, arg1, arg2)
}

65
consensus/consensusclient/mock_consensusclient/mock_consensusclient.go
View file

@ -23,7 +23,6 @@ import (
type MockService struct {
ctrl *gomock.Controller
recorder *MockServiceMockRecorder
isgomock struct{}
}
// MockServiceMockRecorder is the mock recorder for MockService.
@ -44,74 +43,74 @@ func (m *MockService) EXPECT() *MockServiceMockRecorder {
}
// AddLog mocks base method.
func (m *MockService) AddLog(ctx context.Context, logId string, rec *consensusproto.RawRecordWithId) error {
func (m *MockService) AddLog(arg0 context.Context, arg1 string, arg2 *consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddLog", ctx, logId, rec)
ret := m.ctrl.Call(m, "AddLog", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// AddLog indicates an expected call of AddLog.
func (mr *MockServiceMockRecorder) AddLog(ctx, logId, rec any) *gomock.Call {
func (mr *MockServiceMockRecorder) AddLog(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLog", reflect.TypeOf((*MockService)(nil).AddLog), ctx, logId, rec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLog", reflect.TypeOf((*MockService)(nil).AddLog), arg0, arg1, arg2)
}
// AddRecord mocks base method.
func (m *MockService) AddRecord(ctx context.Context, logId string, rec *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
func (m *MockService) AddRecord(arg0 context.Context, arg1 string, arg2 *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRecord", ctx, logId, rec)
ret := m.ctrl.Call(m, "AddRecord", arg0, arg1, arg2)
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRecord indicates an expected call of AddRecord.
func (mr *MockServiceMockRecorder) AddRecord(ctx, logId, rec any) *gomock.Call {
func (mr *MockServiceMockRecorder) AddRecord(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecord", reflect.TypeOf((*MockService)(nil).AddRecord), ctx, logId, rec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecord", reflect.TypeOf((*MockService)(nil).AddRecord), arg0, arg1, arg2)
}
// Close mocks base method.
func (m *MockService) Close(ctx context.Context) error {
func (m *MockService) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockServiceMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockServiceMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockService)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockService)(nil).Close), arg0)
}
// DeleteLog mocks base method.
func (m *MockService) DeleteLog(ctx context.Context, logId string) error {
func (m *MockService) DeleteLog(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteLog", ctx, logId)
ret := m.ctrl.Call(m, "DeleteLog", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteLog indicates an expected call of DeleteLog.
func (mr *MockServiceMockRecorder) DeleteLog(ctx, logId any) *gomock.Call {
func (mr *MockServiceMockRecorder) DeleteLog(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLog", reflect.TypeOf((*MockService)(nil).DeleteLog), ctx, logId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLog", reflect.TypeOf((*MockService)(nil).DeleteLog), arg0, arg1)
}
// Init mocks base method.
func (m *MockService) Init(a *app.App) error {
func (m *MockService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), arg0)
}
// Name mocks base method.
@ -129,43 +128,43 @@ func (mr *MockServiceMockRecorder) Name() *gomock.Call {
}
// Run mocks base method.
func (m *MockService) Run(ctx context.Context) error {
func (m *MockService) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockServiceMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockServiceMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockService)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockService)(nil).Run), arg0)
}
// UnWatch mocks base method.
func (m *MockService) UnWatch(logId string) error {
func (m *MockService) UnWatch(arg0 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UnWatch", logId)
ret := m.ctrl.Call(m, "UnWatch", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// UnWatch indicates an expected call of UnWatch.
func (mr *MockServiceMockRecorder) UnWatch(logId any) *gomock.Call {
func (mr *MockServiceMockRecorder) UnWatch(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnWatch", reflect.TypeOf((*MockService)(nil).UnWatch), logId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnWatch", reflect.TypeOf((*MockService)(nil).UnWatch), arg0)
}
// Watch mocks base method.
func (m *MockService) Watch(logId string, w consensusclient.Watcher) error {
func (m *MockService) Watch(arg0 string, arg1 consensusclient.Watcher) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Watch", logId, w)
ret := m.ctrl.Call(m, "Watch", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Watch indicates an expected call of Watch.
func (mr *MockServiceMockRecorder) Watch(logId, w any) *gomock.Call {
func (mr *MockServiceMockRecorder) Watch(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockService)(nil).Watch), logId, w)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockService)(nil).Watch), arg0, arg1)
}

145
coordinator/coordinatorclient/mock_coordinatorclient/mock_coordinatorclient.go
View file

@ -25,7 +25,6 @@ import (
type MockCoordinatorClient struct {
ctrl *gomock.Controller
recorder *MockCoordinatorClientMockRecorder
isgomock struct{}
}
// MockCoordinatorClientMockRecorder is the mock recorder for MockCoordinatorClient.
@ -46,164 +45,164 @@ func (m *MockCoordinatorClient) EXPECT() *MockCoordinatorClientMockRecorder {
}
// AccountDelete mocks base method.
func (m *MockCoordinatorClient) AccountDelete(ctx context.Context, conf *coordinatorproto.DeletionConfirmPayloadWithSignature) (int64, error) {
func (m *MockCoordinatorClient) AccountDelete(arg0 context.Context, arg1 *coordinatorproto.DeletionConfirmPayloadWithSignature) (int64, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AccountDelete", ctx, conf)
ret := m.ctrl.Call(m, "AccountDelete", arg0, arg1)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AccountDelete indicates an expected call of AccountDelete.
func (mr *MockCoordinatorClientMockRecorder) AccountDelete(ctx, conf any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) AccountDelete(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountDelete", reflect.TypeOf((*MockCoordinatorClient)(nil).AccountDelete), ctx, conf)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountDelete", reflect.TypeOf((*MockCoordinatorClient)(nil).AccountDelete), arg0, arg1)
}
// AccountLimitsSet mocks base method.
func (m *MockCoordinatorClient) AccountLimitsSet(ctx context.Context, req *coordinatorproto.AccountLimitsSetRequest) error {
func (m *MockCoordinatorClient) AccountLimitsSet(arg0 context.Context, arg1 *coordinatorproto.AccountLimitsSetRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AccountLimitsSet", ctx, req)
ret := m.ctrl.Call(m, "AccountLimitsSet", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AccountLimitsSet indicates an expected call of AccountLimitsSet.
func (mr *MockCoordinatorClientMockRecorder) AccountLimitsSet(ctx, req any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) AccountLimitsSet(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountLimitsSet", reflect.TypeOf((*MockCoordinatorClient)(nil).AccountLimitsSet), ctx, req)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountLimitsSet", reflect.TypeOf((*MockCoordinatorClient)(nil).AccountLimitsSet), arg0, arg1)
}
// AccountRevertDeletion mocks base method.
func (m *MockCoordinatorClient) AccountRevertDeletion(ctx context.Context) error {
func (m *MockCoordinatorClient) AccountRevertDeletion(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AccountRevertDeletion", ctx)
ret := m.ctrl.Call(m, "AccountRevertDeletion", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// AccountRevertDeletion indicates an expected call of AccountRevertDeletion.
func (mr *MockCoordinatorClientMockRecorder) AccountRevertDeletion(ctx any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) AccountRevertDeletion(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountRevertDeletion", reflect.TypeOf((*MockCoordinatorClient)(nil).AccountRevertDeletion), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountRevertDeletion", reflect.TypeOf((*MockCoordinatorClient)(nil).AccountRevertDeletion), arg0)
}
// AclAddRecord mocks base method.
func (m *MockCoordinatorClient) AclAddRecord(ctx context.Context, spaceId string, rec *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
func (m *MockCoordinatorClient) AclAddRecord(arg0 context.Context, arg1 string, arg2 *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclAddRecord", ctx, spaceId, rec)
ret := m.ctrl.Call(m, "AclAddRecord", arg0, arg1, arg2)
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclAddRecord indicates an expected call of AclAddRecord.
func (mr *MockCoordinatorClientMockRecorder) AclAddRecord(ctx, spaceId, rec any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) AclAddRecord(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclAddRecord", reflect.TypeOf((*MockCoordinatorClient)(nil).AclAddRecord), ctx, spaceId, rec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclAddRecord", reflect.TypeOf((*MockCoordinatorClient)(nil).AclAddRecord), arg0, arg1, arg2)
}
// AclEventLog mocks base method.
func (m *MockCoordinatorClient) AclEventLog(ctx context.Context, accountId, lastRecordId string, limit int) ([]*coordinatorproto.AclEventLogRecord, error) {
func (m *MockCoordinatorClient) AclEventLog(arg0 context.Context, arg1, arg2 string, arg3 int) ([]*coordinatorproto.AclEventLogRecord, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclEventLog", ctx, accountId, lastRecordId, limit)
ret := m.ctrl.Call(m, "AclEventLog", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].([]*coordinatorproto.AclEventLogRecord)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclEventLog indicates an expected call of AclEventLog.
func (mr *MockCoordinatorClientMockRecorder) AclEventLog(ctx, accountId, lastRecordId, limit any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) AclEventLog(arg0, arg1, arg2, arg3 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclEventLog", reflect.TypeOf((*MockCoordinatorClient)(nil).AclEventLog), ctx, accountId, lastRecordId, limit)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclEventLog", reflect.TypeOf((*MockCoordinatorClient)(nil).AclEventLog), arg0, arg1, arg2, arg3)
}
// AclGetRecords mocks base method.
func (m *MockCoordinatorClient) AclGetRecords(ctx context.Context, spaceId, aclHead string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockCoordinatorClient) AclGetRecords(arg0 context.Context, arg1, arg2 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclGetRecords", ctx, spaceId, aclHead)
ret := m.ctrl.Call(m, "AclGetRecords", arg0, arg1, arg2)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclGetRecords indicates an expected call of AclGetRecords.
func (mr *MockCoordinatorClientMockRecorder) AclGetRecords(ctx, spaceId, aclHead any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) AclGetRecords(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockCoordinatorClient)(nil).AclGetRecords), ctx, spaceId, aclHead)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockCoordinatorClient)(nil).AclGetRecords), arg0, arg1, arg2)
}
// DeletionLog mocks base method.
func (m *MockCoordinatorClient) DeletionLog(ctx context.Context, lastRecordId string, limit int) ([]*coordinatorproto.DeletionLogRecord, error) {
func (m *MockCoordinatorClient) DeletionLog(arg0 context.Context, arg1 string, arg2 int) ([]*coordinatorproto.DeletionLogRecord, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeletionLog", ctx, lastRecordId, limit)
ret := m.ctrl.Call(m, "DeletionLog", arg0, arg1, arg2)
ret0, _ := ret[0].([]*coordinatorproto.DeletionLogRecord)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeletionLog indicates an expected call of DeletionLog.
func (mr *MockCoordinatorClientMockRecorder) DeletionLog(ctx, lastRecordId, limit any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) DeletionLog(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletionLog", reflect.TypeOf((*MockCoordinatorClient)(nil).DeletionLog), ctx, lastRecordId, limit)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletionLog", reflect.TypeOf((*MockCoordinatorClient)(nil).DeletionLog), arg0, arg1, arg2)
}
// IdentityRepoGet mocks base method.
func (m *MockCoordinatorClient) IdentityRepoGet(ctx context.Context, identities, kinds []string) ([]*identityrepoproto.DataWithIdentity, error) {
func (m *MockCoordinatorClient) IdentityRepoGet(arg0 context.Context, arg1, arg2 []string) ([]*identityrepoproto.DataWithIdentity, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IdentityRepoGet", ctx, identities, kinds)
ret := m.ctrl.Call(m, "IdentityRepoGet", arg0, arg1, arg2)
ret0, _ := ret[0].([]*identityrepoproto.DataWithIdentity)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IdentityRepoGet indicates an expected call of IdentityRepoGet.
func (mr *MockCoordinatorClientMockRecorder) IdentityRepoGet(ctx, identities, kinds any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) IdentityRepoGet(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityRepoGet", reflect.TypeOf((*MockCoordinatorClient)(nil).IdentityRepoGet), ctx, identities, kinds)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityRepoGet", reflect.TypeOf((*MockCoordinatorClient)(nil).IdentityRepoGet), arg0, arg1, arg2)
}
// IdentityRepoPut mocks base method.
func (m *MockCoordinatorClient) IdentityRepoPut(ctx context.Context, identity string, data []*identityrepoproto.Data) error {
func (m *MockCoordinatorClient) IdentityRepoPut(arg0 context.Context, arg1 string, arg2 []*identityrepoproto.Data) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IdentityRepoPut", ctx, identity, data)
ret := m.ctrl.Call(m, "IdentityRepoPut", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// IdentityRepoPut indicates an expected call of IdentityRepoPut.
func (mr *MockCoordinatorClientMockRecorder) IdentityRepoPut(ctx, identity, data any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) IdentityRepoPut(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityRepoPut", reflect.TypeOf((*MockCoordinatorClient)(nil).IdentityRepoPut), ctx, identity, data)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityRepoPut", reflect.TypeOf((*MockCoordinatorClient)(nil).IdentityRepoPut), arg0, arg1, arg2)
}
// Init mocks base method.
func (m *MockCoordinatorClient) Init(a *app.App) error {
func (m *MockCoordinatorClient) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockCoordinatorClientMockRecorder) Init(a any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockCoordinatorClient)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockCoordinatorClient)(nil).Init), arg0)
}
// IsNetworkNeedsUpdate mocks base method.
func (m *MockCoordinatorClient) IsNetworkNeedsUpdate(ctx context.Context) (bool, error) {
func (m *MockCoordinatorClient) IsNetworkNeedsUpdate(arg0 context.Context) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsNetworkNeedsUpdate", ctx)
ret := m.ctrl.Call(m, "IsNetworkNeedsUpdate", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsNetworkNeedsUpdate indicates an expected call of IsNetworkNeedsUpdate.
func (mr *MockCoordinatorClientMockRecorder) IsNetworkNeedsUpdate(ctx any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) IsNetworkNeedsUpdate(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNetworkNeedsUpdate", reflect.TypeOf((*MockCoordinatorClient)(nil).IsNetworkNeedsUpdate), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNetworkNeedsUpdate", reflect.TypeOf((*MockCoordinatorClient)(nil).IsNetworkNeedsUpdate), arg0)
}
// Name mocks base method.
@ -221,96 +220,96 @@ func (mr *MockCoordinatorClientMockRecorder) Name() *gomock.Call {
}
// NetworkConfiguration mocks base method.
func (m *MockCoordinatorClient) NetworkConfiguration(ctx context.Context, currentId string) (*coordinatorproto.NetworkConfigurationResponse, error) {
func (m *MockCoordinatorClient) NetworkConfiguration(arg0 context.Context, arg1 string) (*coordinatorproto.NetworkConfigurationResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NetworkConfiguration", ctx, currentId)
ret := m.ctrl.Call(m, "NetworkConfiguration", arg0, arg1)
ret0, _ := ret[0].(*coordinatorproto.NetworkConfigurationResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// NetworkConfiguration indicates an expected call of NetworkConfiguration.
func (mr *MockCoordinatorClientMockRecorder) NetworkConfiguration(ctx, currentId any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) NetworkConfiguration(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkConfiguration", reflect.TypeOf((*MockCoordinatorClient)(nil).NetworkConfiguration), ctx, currentId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkConfiguration", reflect.TypeOf((*MockCoordinatorClient)(nil).NetworkConfiguration), arg0, arg1)
}
// SpaceDelete mocks base method.
func (m *MockCoordinatorClient) SpaceDelete(ctx context.Context, spaceId string, conf *coordinatorproto.DeletionConfirmPayloadWithSignature) error {
func (m *MockCoordinatorClient) SpaceDelete(arg0 context.Context, arg1 string, arg2 *coordinatorproto.DeletionConfirmPayloadWithSignature) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceDelete", ctx, spaceId, conf)
ret := m.ctrl.Call(m, "SpaceDelete", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// SpaceDelete indicates an expected call of SpaceDelete.
func (mr *MockCoordinatorClientMockRecorder) SpaceDelete(ctx, spaceId, conf any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) SpaceDelete(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceDelete", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceDelete), ctx, spaceId, conf)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceDelete", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceDelete), arg0, arg1, arg2)
}
// SpaceMakeShareable mocks base method.
func (m *MockCoordinatorClient) SpaceMakeShareable(ctx context.Context, spaceId string) error {
func (m *MockCoordinatorClient) SpaceMakeShareable(arg0 context.Context, arg1 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceMakeShareable", ctx, spaceId)
ret := m.ctrl.Call(m, "SpaceMakeShareable", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// SpaceMakeShareable indicates an expected call of SpaceMakeShareable.
func (mr *MockCoordinatorClientMockRecorder) SpaceMakeShareable(ctx, spaceId any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) SpaceMakeShareable(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceMakeShareable", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceMakeShareable), ctx, spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceMakeShareable", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceMakeShareable), arg0, arg1)
}
// SpaceMakeUnshareable mocks base method.
func (m *MockCoordinatorClient) SpaceMakeUnshareable(ctx context.Context, spaceId, aclId string) error {
func (m *MockCoordinatorClient) SpaceMakeUnshareable(arg0 context.Context, arg1, arg2 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceMakeUnshareable", ctx, spaceId, aclId)
ret := m.ctrl.Call(m, "SpaceMakeUnshareable", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
}
// SpaceMakeUnshareable indicates an expected call of SpaceMakeUnshareable.
func (mr *MockCoordinatorClientMockRecorder) SpaceMakeUnshareable(ctx, spaceId, aclId any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) SpaceMakeUnshareable(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceMakeUnshareable", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceMakeUnshareable), ctx, spaceId, aclId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceMakeUnshareable", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceMakeUnshareable), arg0, arg1, arg2)
}
// SpaceSign mocks base method.
func (m *MockCoordinatorClient) SpaceSign(ctx context.Context, payload coordinatorclient.SpaceSignPayload) (*coordinatorproto.SpaceReceiptWithSignature, error) {
func (m *MockCoordinatorClient) SpaceSign(arg0 context.Context, arg1 coordinatorclient.SpaceSignPayload) (*coordinatorproto.SpaceReceiptWithSignature, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceSign", ctx, payload)
ret := m.ctrl.Call(m, "SpaceSign", arg0, arg1)
ret0, _ := ret[0].(*coordinatorproto.SpaceReceiptWithSignature)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SpaceSign indicates an expected call of SpaceSign.
func (mr *MockCoordinatorClientMockRecorder) SpaceSign(ctx, payload any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) SpaceSign(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceSign", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceSign), ctx, payload)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceSign", reflect.TypeOf((*MockCoordinatorClient)(nil).SpaceSign), arg0, arg1)
}
// StatusCheck mocks base method.
func (m *MockCoordinatorClient) StatusCheck(ctx context.Context, spaceId string) (*coordinatorproto.SpaceStatusPayload, error) {
func (m *MockCoordinatorClient) StatusCheck(arg0 context.Context, arg1 string) (*coordinatorproto.SpaceStatusPayload, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StatusCheck", ctx, spaceId)
ret := m.ctrl.Call(m, "StatusCheck", arg0, arg1)
ret0, _ := ret[0].(*coordinatorproto.SpaceStatusPayload)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StatusCheck indicates an expected call of StatusCheck.
func (mr *MockCoordinatorClientMockRecorder) StatusCheck(ctx, spaceId any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) StatusCheck(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatusCheck", reflect.TypeOf((*MockCoordinatorClient)(nil).StatusCheck), ctx, spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatusCheck", reflect.TypeOf((*MockCoordinatorClient)(nil).StatusCheck), arg0, arg1)
}
// StatusCheckMany mocks base method.
func (m *MockCoordinatorClient) StatusCheckMany(ctx context.Context, spaceIds []string) ([]*coordinatorproto.SpaceStatusPayload, *coordinatorproto.AccountLimits, error) {
func (m *MockCoordinatorClient) StatusCheckMany(arg0 context.Context, arg1 []string) ([]*coordinatorproto.SpaceStatusPayload, *coordinatorproto.AccountLimits, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StatusCheckMany", ctx, spaceIds)
ret := m.ctrl.Call(m, "StatusCheckMany", arg0, arg1)
ret0, _ := ret[0].([]*coordinatorproto.SpaceStatusPayload)
ret1, _ := ret[1].(*coordinatorproto.AccountLimits)
ret2, _ := ret[2].(error)
@ -318,7 +317,7 @@ func (m *MockCoordinatorClient) StatusCheckMany(ctx context.Context, spaceIds []
}
// StatusCheckMany indicates an expected call of StatusCheckMany.
func (mr *MockCoordinatorClientMockRecorder) StatusCheckMany(ctx, spaceIds any) *gomock.Call {
func (mr *MockCoordinatorClientMockRecorder) StatusCheckMany(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatusCheckMany", reflect.TypeOf((*MockCoordinatorClient)(nil).StatusCheckMany), ctx, spaceIds)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatusCheckMany", reflect.TypeOf((*MockCoordinatorClient)(nil).StatusCheckMany), arg0, arg1)
}

105
nameservice/nameserviceclient/mock/mock_nameserviceclient.go
View file

@ -22,7 +22,6 @@ import (
type MockAnyNsClientService struct {
ctrl *gomock.Controller
recorder *MockAnyNsClientServiceMockRecorder
isgomock struct{}
}
// MockAnyNsClientServiceMockRecorder is the mock recorder for MockAnyNsClientService.
@ -43,197 +42,197 @@ func (m *MockAnyNsClientService) EXPECT() *MockAnyNsClientServiceMockRecorder {
}
// AdminFundUserAccount mocks base method.
func (m *MockAnyNsClientService) AdminFundUserAccount(ctx context.Context, in *nameserviceproto.AdminFundUserAccountRequestSigned) (*nameserviceproto.OperationResponse, error) {
func (m *MockAnyNsClientService) AdminFundUserAccount(arg0 context.Context, arg1 *nameserviceproto.AdminFundUserAccountRequestSigned) (*nameserviceproto.OperationResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AdminFundUserAccount", ctx, in)
ret := m.ctrl.Call(m, "AdminFundUserAccount", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.OperationResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AdminFundUserAccount indicates an expected call of AdminFundUserAccount.
func (mr *MockAnyNsClientServiceMockRecorder) AdminFundUserAccount(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) AdminFundUserAccount(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminFundUserAccount", reflect.TypeOf((*MockAnyNsClientService)(nil).AdminFundUserAccount), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminFundUserAccount", reflect.TypeOf((*MockAnyNsClientService)(nil).AdminFundUserAccount), arg0, arg1)
}
// AdminRegisterName mocks base method.
func (m *MockAnyNsClientService) AdminRegisterName(ctx context.Context, in *nameserviceproto.NameRegisterRequestSigned) (*nameserviceproto.OperationResponse, error) {
func (m *MockAnyNsClientService) AdminRegisterName(arg0 context.Context, arg1 *nameserviceproto.NameRegisterRequestSigned) (*nameserviceproto.OperationResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AdminRegisterName", ctx, in)
ret := m.ctrl.Call(m, "AdminRegisterName", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.OperationResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AdminRegisterName indicates an expected call of AdminRegisterName.
func (mr *MockAnyNsClientServiceMockRecorder) AdminRegisterName(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) AdminRegisterName(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRegisterName", reflect.TypeOf((*MockAnyNsClientService)(nil).AdminRegisterName), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRegisterName", reflect.TypeOf((*MockAnyNsClientService)(nil).AdminRegisterName), arg0, arg1)
}
// AdminRenewName mocks base method.
func (m *MockAnyNsClientService) AdminRenewName(ctx context.Context, in *nameserviceproto.NameRenewRequestSigned) (*nameserviceproto.OperationResponse, error) {
func (m *MockAnyNsClientService) AdminRenewName(arg0 context.Context, arg1 *nameserviceproto.NameRenewRequestSigned) (*nameserviceproto.OperationResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AdminRenewName", ctx, in)
ret := m.ctrl.Call(m, "AdminRenewName", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.OperationResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AdminRenewName indicates an expected call of AdminRenewName.
func (mr *MockAnyNsClientServiceMockRecorder) AdminRenewName(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) AdminRenewName(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRenewName", reflect.TypeOf((*MockAnyNsClientService)(nil).AdminRenewName), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRenewName", reflect.TypeOf((*MockAnyNsClientService)(nil).AdminRenewName), arg0, arg1)
}
// BatchGetNameByAddress mocks base method.
func (m *MockAnyNsClientService) BatchGetNameByAddress(ctx context.Context, in *nameserviceproto.BatchNameByAddressRequest) (*nameserviceproto.BatchNameByAddressResponse, error) {
func (m *MockAnyNsClientService) BatchGetNameByAddress(arg0 context.Context, arg1 *nameserviceproto.BatchNameByAddressRequest) (*nameserviceproto.BatchNameByAddressResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BatchGetNameByAddress", ctx, in)
ret := m.ctrl.Call(m, "BatchGetNameByAddress", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.BatchNameByAddressResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BatchGetNameByAddress indicates an expected call of BatchGetNameByAddress.
func (mr *MockAnyNsClientServiceMockRecorder) BatchGetNameByAddress(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) BatchGetNameByAddress(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNameByAddress", reflect.TypeOf((*MockAnyNsClientService)(nil).BatchGetNameByAddress), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNameByAddress", reflect.TypeOf((*MockAnyNsClientService)(nil).BatchGetNameByAddress), arg0, arg1)
}
// BatchGetNameByAnyId mocks base method.
func (m *MockAnyNsClientService) BatchGetNameByAnyId(ctx context.Context, in *nameserviceproto.BatchNameByAnyIdRequest) (*nameserviceproto.BatchNameByAddressResponse, error) {
func (m *MockAnyNsClientService) BatchGetNameByAnyId(arg0 context.Context, arg1 *nameserviceproto.BatchNameByAnyIdRequest) (*nameserviceproto.BatchNameByAddressResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BatchGetNameByAnyId", ctx, in)
ret := m.ctrl.Call(m, "BatchGetNameByAnyId", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.BatchNameByAddressResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BatchGetNameByAnyId indicates an expected call of BatchGetNameByAnyId.
func (mr *MockAnyNsClientServiceMockRecorder) BatchGetNameByAnyId(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) BatchGetNameByAnyId(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNameByAnyId", reflect.TypeOf((*MockAnyNsClientService)(nil).BatchGetNameByAnyId), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNameByAnyId", reflect.TypeOf((*MockAnyNsClientService)(nil).BatchGetNameByAnyId), arg0, arg1)
}
// BatchIsNameAvailable mocks base method.
func (m *MockAnyNsClientService) BatchIsNameAvailable(ctx context.Context, in *nameserviceproto.BatchNameAvailableRequest) (*nameserviceproto.BatchNameAvailableResponse, error) {
func (m *MockAnyNsClientService) BatchIsNameAvailable(arg0 context.Context, arg1 *nameserviceproto.BatchNameAvailableRequest) (*nameserviceproto.BatchNameAvailableResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BatchIsNameAvailable", ctx, in)
ret := m.ctrl.Call(m, "BatchIsNameAvailable", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.BatchNameAvailableResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BatchIsNameAvailable indicates an expected call of BatchIsNameAvailable.
func (mr *MockAnyNsClientServiceMockRecorder) BatchIsNameAvailable(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) BatchIsNameAvailable(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchIsNameAvailable", reflect.TypeOf((*MockAnyNsClientService)(nil).BatchIsNameAvailable), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchIsNameAvailable", reflect.TypeOf((*MockAnyNsClientService)(nil).BatchIsNameAvailable), arg0, arg1)
}
// CreateOperation mocks base method.
func (m *MockAnyNsClientService) CreateOperation(ctx context.Context, in *nameserviceproto.CreateUserOperationRequestSigned) (*nameserviceproto.OperationResponse, error) {
func (m *MockAnyNsClientService) CreateOperation(arg0 context.Context, arg1 *nameserviceproto.CreateUserOperationRequestSigned) (*nameserviceproto.OperationResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOperation", ctx, in)
ret := m.ctrl.Call(m, "CreateOperation", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.OperationResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateOperation indicates an expected call of CreateOperation.
func (mr *MockAnyNsClientServiceMockRecorder) CreateOperation(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) CreateOperation(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOperation", reflect.TypeOf((*MockAnyNsClientService)(nil).CreateOperation), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOperation", reflect.TypeOf((*MockAnyNsClientService)(nil).CreateOperation), arg0, arg1)
}
// GetNameByAddress mocks base method.
func (m *MockAnyNsClientService) GetNameByAddress(ctx context.Context, in *nameserviceproto.NameByAddressRequest) (*nameserviceproto.NameByAddressResponse, error) {
func (m *MockAnyNsClientService) GetNameByAddress(arg0 context.Context, arg1 *nameserviceproto.NameByAddressRequest) (*nameserviceproto.NameByAddressResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNameByAddress", ctx, in)
ret := m.ctrl.Call(m, "GetNameByAddress", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.NameByAddressResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNameByAddress indicates an expected call of GetNameByAddress.
func (mr *MockAnyNsClientServiceMockRecorder) GetNameByAddress(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) GetNameByAddress(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNameByAddress", reflect.TypeOf((*MockAnyNsClientService)(nil).GetNameByAddress), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNameByAddress", reflect.TypeOf((*MockAnyNsClientService)(nil).GetNameByAddress), arg0, arg1)
}
// GetNameByAnyId mocks base method.
func (m *MockAnyNsClientService) GetNameByAnyId(ctx context.Context, in *nameserviceproto.NameByAnyIdRequest) (*nameserviceproto.NameByAddressResponse, error) {
func (m *MockAnyNsClientService) GetNameByAnyId(arg0 context.Context, arg1 *nameserviceproto.NameByAnyIdRequest) (*nameserviceproto.NameByAddressResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNameByAnyId", ctx, in)
ret := m.ctrl.Call(m, "GetNameByAnyId", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.NameByAddressResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNameByAnyId indicates an expected call of GetNameByAnyId.
func (mr *MockAnyNsClientServiceMockRecorder) GetNameByAnyId(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) GetNameByAnyId(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNameByAnyId", reflect.TypeOf((*MockAnyNsClientService)(nil).GetNameByAnyId), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNameByAnyId", reflect.TypeOf((*MockAnyNsClientService)(nil).GetNameByAnyId), arg0, arg1)
}
// GetOperation mocks base method.
func (m *MockAnyNsClientService) GetOperation(ctx context.Context, in *nameserviceproto.GetOperationStatusRequest) (*nameserviceproto.OperationResponse, error) {
func (m *MockAnyNsClientService) GetOperation(arg0 context.Context, arg1 *nameserviceproto.GetOperationStatusRequest) (*nameserviceproto.OperationResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetOperation", ctx, in)
ret := m.ctrl.Call(m, "GetOperation", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.OperationResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetOperation indicates an expected call of GetOperation.
func (mr *MockAnyNsClientServiceMockRecorder) GetOperation(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) GetOperation(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperation", reflect.TypeOf((*MockAnyNsClientService)(nil).GetOperation), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperation", reflect.TypeOf((*MockAnyNsClientService)(nil).GetOperation), arg0, arg1)
}
// GetUserAccount mocks base method.
func (m *MockAnyNsClientService) GetUserAccount(ctx context.Context, in *nameserviceproto.GetUserAccountRequest) (*nameserviceproto.UserAccount, error) {
func (m *MockAnyNsClientService) GetUserAccount(arg0 context.Context, arg1 *nameserviceproto.GetUserAccountRequest) (*nameserviceproto.UserAccount, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetUserAccount", ctx, in)
ret := m.ctrl.Call(m, "GetUserAccount", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.UserAccount)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetUserAccount indicates an expected call of GetUserAccount.
func (mr *MockAnyNsClientServiceMockRecorder) GetUserAccount(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) GetUserAccount(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAccount", reflect.TypeOf((*MockAnyNsClientService)(nil).GetUserAccount), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAccount", reflect.TypeOf((*MockAnyNsClientService)(nil).GetUserAccount), arg0, arg1)
}
// Init mocks base method.
func (m *MockAnyNsClientService) Init(a *app.App) error {
func (m *MockAnyNsClientService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockAnyNsClientServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAnyNsClientService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAnyNsClientService)(nil).Init), arg0)
}
// IsNameAvailable mocks base method.
func (m *MockAnyNsClientService) IsNameAvailable(ctx context.Context, in *nameserviceproto.NameAvailableRequest) (*nameserviceproto.NameAvailableResponse, error) {
func (m *MockAnyNsClientService) IsNameAvailable(arg0 context.Context, arg1 *nameserviceproto.NameAvailableRequest) (*nameserviceproto.NameAvailableResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsNameAvailable", ctx, in)
ret := m.ctrl.Call(m, "IsNameAvailable", arg0, arg1)
ret0, _ := ret[0].(*nameserviceproto.NameAvailableResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsNameAvailable indicates an expected call of IsNameAvailable.
func (mr *MockAnyNsClientServiceMockRecorder) IsNameAvailable(ctx, in any) *gomock.Call {
func (mr *MockAnyNsClientServiceMockRecorder) IsNameAvailable(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNameAvailable", reflect.TypeOf((*MockAnyNsClientService)(nil).IsNameAvailable), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNameAvailable", reflect.TypeOf((*MockAnyNsClientService)(nil).IsNameAvailable), arg0, arg1)
}
// Name mocks base method.

41
net/peer/mock_peer/mock_peer.go
View file

@ -22,7 +22,6 @@ import (
type MockPeer struct {
ctrl *gomock.Controller
recorder *MockPeerMockRecorder
isgomock struct{}
}
// MockPeerMockRecorder is the mock recorder for MockPeer.
@ -43,18 +42,18 @@ func (m *MockPeer) EXPECT() *MockPeerMockRecorder {
}
// AcquireDrpcConn mocks base method.
func (m *MockPeer) AcquireDrpcConn(ctx context.Context) (drpc.Conn, error) {
func (m *MockPeer) AcquireDrpcConn(arg0 context.Context) (drpc.Conn, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AcquireDrpcConn", ctx)
ret := m.ctrl.Call(m, "AcquireDrpcConn", arg0)
ret0, _ := ret[0].(drpc.Conn)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AcquireDrpcConn indicates an expected call of AcquireDrpcConn.
func (mr *MockPeerMockRecorder) AcquireDrpcConn(ctx any) *gomock.Call {
func (mr *MockPeerMockRecorder) AcquireDrpcConn(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireDrpcConn", reflect.TypeOf((*MockPeer)(nil).AcquireDrpcConn), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireDrpcConn", reflect.TypeOf((*MockPeer)(nil).AcquireDrpcConn), arg0)
}
// Close mocks base method.
@ -100,17 +99,17 @@ func (mr *MockPeerMockRecorder) Context() *gomock.Call {
}
// DoDrpc mocks base method.
func (m *MockPeer) DoDrpc(ctx context.Context, do func(drpc.Conn) error) error {
func (m *MockPeer) DoDrpc(arg0 context.Context, arg1 func(drpc.Conn) error) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DoDrpc", ctx, do)
ret := m.ctrl.Call(m, "DoDrpc", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// DoDrpc indicates an expected call of DoDrpc.
func (mr *MockPeerMockRecorder) DoDrpc(ctx, do any) *gomock.Call {
func (mr *MockPeerMockRecorder) DoDrpc(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoDrpc", reflect.TypeOf((*MockPeer)(nil).DoDrpc), ctx, do)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoDrpc", reflect.TypeOf((*MockPeer)(nil).DoDrpc), arg0, arg1)
}
// Id mocks base method.
@ -142,40 +141,40 @@ func (mr *MockPeerMockRecorder) IsClosed() *gomock.Call {
}
// ReleaseDrpcConn mocks base method.
func (m *MockPeer) ReleaseDrpcConn(conn drpc.Conn) {
func (m *MockPeer) ReleaseDrpcConn(arg0 drpc.Conn) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ReleaseDrpcConn", conn)
m.ctrl.Call(m, "ReleaseDrpcConn", arg0)
}
// ReleaseDrpcConn indicates an expected call of ReleaseDrpcConn.
func (mr *MockPeerMockRecorder) ReleaseDrpcConn(conn any) *gomock.Call {
func (mr *MockPeerMockRecorder) ReleaseDrpcConn(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseDrpcConn", reflect.TypeOf((*MockPeer)(nil).ReleaseDrpcConn), conn)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseDrpcConn", reflect.TypeOf((*MockPeer)(nil).ReleaseDrpcConn), arg0)
}
// SetTTL mocks base method.
func (m *MockPeer) SetTTL(ttl time.Duration) {
func (m *MockPeer) SetTTL(arg0 time.Duration) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTTL", ttl)
m.ctrl.Call(m, "SetTTL", arg0)
}
// SetTTL indicates an expected call of SetTTL.
func (mr *MockPeerMockRecorder) SetTTL(ttl any) *gomock.Call {
func (mr *MockPeerMockRecorder) SetTTL(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTTL", reflect.TypeOf((*MockPeer)(nil).SetTTL), ttl)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTTL", reflect.TypeOf((*MockPeer)(nil).SetTTL), arg0)
}
// TryClose mocks base method.
func (m *MockPeer) TryClose(objectTTL time.Duration) (bool, error) {
func (m *MockPeer) TryClose(arg0 time.Duration) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TryClose", objectTTL)
ret := m.ctrl.Call(m, "TryClose", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TryClose indicates an expected call of TryClose.
func (mr *MockPeerMockRecorder) TryClose(objectTTL any) *gomock.Call {
func (mr *MockPeerMockRecorder) TryClose(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockPeer)(nil).TryClose), objectTTL)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockPeer)(nil).TryClose), arg0)
}

90
net/pool/mock_pool/mock_pool.go
View file

@ -22,7 +22,6 @@ import (
type MockPool struct {
ctrl *gomock.Controller
recorder *MockPoolMockRecorder
isgomock struct{}
}
// MockPoolMockRecorder is the mock recorder for MockPool.
@ -43,69 +42,68 @@ func (m *MockPool) EXPECT() *MockPoolMockRecorder {
}
// AddPeer mocks base method.
func (m *MockPool) AddPeer(ctx context.Context, p peer.Peer) error {
func (m *MockPool) AddPeer(arg0 context.Context, arg1 peer.Peer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddPeer", ctx, p)
ret := m.ctrl.Call(m, "AddPeer", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AddPeer indicates an expected call of AddPeer.
func (mr *MockPoolMockRecorder) AddPeer(ctx, p any) *gomock.Call {
func (mr *MockPoolMockRecorder) AddPeer(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockPool)(nil).AddPeer), ctx, p)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockPool)(nil).AddPeer), arg0, arg1)
}
// Get mocks base method.
func (m *MockPool) Get(ctx context.Context, id string) (peer.Peer, error) {
func (m *MockPool) Get(arg0 context.Context, arg1 string) (peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, id)
ret := m.ctrl.Call(m, "Get", arg0, arg1)
ret0, _ := ret[0].(peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Get indicates an expected call of Get.
func (mr *MockPoolMockRecorder) Get(ctx, id any) *gomock.Call {
func (mr *MockPoolMockRecorder) Get(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPool)(nil).Get), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPool)(nil).Get), arg0, arg1)
}
// GetOneOf mocks base method.
func (m *MockPool) GetOneOf(ctx context.Context, peerIds []string) (peer.Peer, error) {
func (m *MockPool) GetOneOf(arg0 context.Context, arg1 []string) (peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetOneOf", ctx, peerIds)
ret := m.ctrl.Call(m, "GetOneOf", arg0, arg1)
ret0, _ := ret[0].(peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetOneOf indicates an expected call of GetOneOf.
func (mr *MockPoolMockRecorder) GetOneOf(ctx, peerIds any) *gomock.Call {
func (mr *MockPoolMockRecorder) GetOneOf(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneOf", reflect.TypeOf((*MockPool)(nil).GetOneOf), ctx, peerIds)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneOf", reflect.TypeOf((*MockPool)(nil).GetOneOf), arg0, arg1)
}
// Pick mocks base method.
func (m *MockPool) Pick(ctx context.Context, id string) (peer.Peer, error) {
func (m *MockPool) Pick(arg0 context.Context, arg1 string) (peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Pick", ctx, id)
ret := m.ctrl.Call(m, "Pick", arg0, arg1)
ret0, _ := ret[0].(peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Pick indicates an expected call of Pick.
func (mr *MockPoolMockRecorder) Pick(ctx, id any) *gomock.Call {
func (mr *MockPoolMockRecorder) Pick(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pick", reflect.TypeOf((*MockPool)(nil).Pick), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pick", reflect.TypeOf((*MockPool)(nil).Pick), arg0, arg1)
}
// MockService is a mock of Service interface.
type MockService struct {
ctrl *gomock.Controller
recorder *MockServiceMockRecorder
isgomock struct{}
}
// MockServiceMockRecorder is the mock recorder for MockService.
@ -126,75 +124,75 @@ func (m *MockService) EXPECT() *MockServiceMockRecorder {
}
// AddPeer mocks base method.
func (m *MockService) AddPeer(ctx context.Context, p peer.Peer) error {
func (m *MockService) AddPeer(arg0 context.Context, arg1 peer.Peer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddPeer", ctx, p)
ret := m.ctrl.Call(m, "AddPeer", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AddPeer indicates an expected call of AddPeer.
func (mr *MockServiceMockRecorder) AddPeer(ctx, p any) *gomock.Call {
func (mr *MockServiceMockRecorder) AddPeer(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockService)(nil).AddPeer), ctx, p)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockService)(nil).AddPeer), arg0, arg1)
}
// Close mocks base method.
func (m *MockService) Close(ctx context.Context) error {
func (m *MockService) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockServiceMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockServiceMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockService)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockService)(nil).Close), arg0)
}
// Get mocks base method.
func (m *MockService) Get(ctx context.Context, id string) (peer.Peer, error) {
func (m *MockService) Get(arg0 context.Context, arg1 string) (peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, id)
ret := m.ctrl.Call(m, "Get", arg0, arg1)
ret0, _ := ret[0].(peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Get indicates an expected call of Get.
func (mr *MockServiceMockRecorder) Get(ctx, id any) *gomock.Call {
func (mr *MockServiceMockRecorder) Get(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockService)(nil).Get), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockService)(nil).Get), arg0, arg1)
}
// GetOneOf mocks base method.
func (m *MockService) GetOneOf(ctx context.Context, peerIds []string) (peer.Peer, error) {
func (m *MockService) GetOneOf(arg0 context.Context, arg1 []string) (peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetOneOf", ctx, peerIds)
ret := m.ctrl.Call(m, "GetOneOf", arg0, arg1)
ret0, _ := ret[0].(peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetOneOf indicates an expected call of GetOneOf.
func (mr *MockServiceMockRecorder) GetOneOf(ctx, peerIds any) *gomock.Call {
func (mr *MockServiceMockRecorder) GetOneOf(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneOf", reflect.TypeOf((*MockService)(nil).GetOneOf), ctx, peerIds)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneOf", reflect.TypeOf((*MockService)(nil).GetOneOf), arg0, arg1)
}
// Init mocks base method.
func (m *MockService) Init(a *app.App) error {
func (m *MockService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), arg0)
}
// Name mocks base method.
@ -212,30 +210,30 @@ func (mr *MockServiceMockRecorder) Name() *gomock.Call {
}
// Pick mocks base method.
func (m *MockService) Pick(ctx context.Context, id string) (peer.Peer, error) {
func (m *MockService) Pick(arg0 context.Context, arg1 string) (peer.Peer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Pick", ctx, id)
ret := m.ctrl.Call(m, "Pick", arg0, arg1)
ret0, _ := ret[0].(peer.Peer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Pick indicates an expected call of Pick.
func (mr *MockServiceMockRecorder) Pick(ctx, id any) *gomock.Call {
func (mr *MockServiceMockRecorder) Pick(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pick", reflect.TypeOf((*MockService)(nil).Pick), ctx, id)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pick", reflect.TypeOf((*MockService)(nil).Pick), arg0, arg1)
}
// Run mocks base method.
func (m *MockService) Run(ctx context.Context) error {
func (m *MockService) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockServiceMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockServiceMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockService)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockService)(nil).Run), arg0)
}

33
net/rpc/limiter/mock_limiter/mock_limiter.go
View file

@ -22,7 +22,6 @@ import (
type MockRpcLimiter struct {
ctrl *gomock.Controller
recorder *MockRpcLimiterMockRecorder
isgomock struct{}
}
// MockRpcLimiterMockRecorder is the mock recorder for MockRpcLimiter.
@ -43,31 +42,31 @@ func (m *MockRpcLimiter) EXPECT() *MockRpcLimiterMockRecorder {
}
// Close mocks base method.
func (m *MockRpcLimiter) Close(ctx context.Context) error {
func (m *MockRpcLimiter) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockRpcLimiterMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockRpcLimiterMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRpcLimiter)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRpcLimiter)(nil).Close), arg0)
}
// Init mocks base method.
func (m *MockRpcLimiter) Init(a *app.App) error {
func (m *MockRpcLimiter) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockRpcLimiterMockRecorder) Init(a any) *gomock.Call {
func (mr *MockRpcLimiterMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockRpcLimiter)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockRpcLimiter)(nil).Init), arg0)
}
// Name mocks base method.
@ -85,29 +84,29 @@ func (mr *MockRpcLimiterMockRecorder) Name() *gomock.Call {
}
// Run mocks base method.
func (m *MockRpcLimiter) Run(ctx context.Context) error {
func (m *MockRpcLimiter) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockRpcLimiterMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockRpcLimiterMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockRpcLimiter)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockRpcLimiter)(nil).Run), arg0)
}
// WrapDRPCHandler mocks base method.
func (m *MockRpcLimiter) WrapDRPCHandler(handler drpc.Handler) drpc.Handler {
func (m *MockRpcLimiter) WrapDRPCHandler(arg0 drpc.Handler) drpc.Handler {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WrapDRPCHandler", handler)
ret := m.ctrl.Call(m, "WrapDRPCHandler", arg0)
ret0, _ := ret[0].(drpc.Handler)
return ret0
}
// WrapDRPCHandler indicates an expected call of WrapDRPCHandler.
func (mr *MockRpcLimiterMockRecorder) WrapDRPCHandler(handler any) *gomock.Call {
func (mr *MockRpcLimiterMockRecorder) WrapDRPCHandler(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WrapDRPCHandler", reflect.TypeOf((*MockRpcLimiter)(nil).WrapDRPCHandler), handler)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WrapDRPCHandler", reflect.TypeOf((*MockRpcLimiter)(nil).WrapDRPCHandler), arg0)
}

26
net/transport/mock_transport/mock_transport.go
View file

@ -22,7 +22,6 @@ import (
type MockTransport struct {
ctrl *gomock.Controller
recorder *MockTransportMockRecorder
isgomock struct{}
}
// MockTransportMockRecorder is the mock recorder for MockTransport.
@ -43,37 +42,36 @@ func (m *MockTransport) EXPECT() *MockTransportMockRecorder {
}
// Dial mocks base method.
func (m *MockTransport) Dial(ctx context.Context, addr string) (transport.MultiConn, error) {
func (m *MockTransport) Dial(arg0 context.Context, arg1 string) (transport.MultiConn, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Dial", ctx, addr)
ret := m.ctrl.Call(m, "Dial", arg0, arg1)
ret0, _ := ret[0].(transport.MultiConn)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Dial indicates an expected call of Dial.
func (mr *MockTransportMockRecorder) Dial(ctx, addr any) *gomock.Call {
func (mr *MockTransportMockRecorder) Dial(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dial", reflect.TypeOf((*MockTransport)(nil).Dial), ctx, addr)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dial", reflect.TypeOf((*MockTransport)(nil).Dial), arg0, arg1)
}
// SetAccepter mocks base method.
func (m *MockTransport) SetAccepter(accepter transport.Accepter) {
func (m *MockTransport) SetAccepter(arg0 transport.Accepter) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetAccepter", accepter)
m.ctrl.Call(m, "SetAccepter", arg0)
}
// SetAccepter indicates an expected call of SetAccepter.
func (mr *MockTransportMockRecorder) SetAccepter(accepter any) *gomock.Call {
func (mr *MockTransportMockRecorder) SetAccepter(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccepter", reflect.TypeOf((*MockTransport)(nil).SetAccepter), accepter)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccepter", reflect.TypeOf((*MockTransport)(nil).SetAccepter), arg0)
}
// MockMultiConn is a mock of MultiConn interface.
type MockMultiConn struct {
ctrl *gomock.Controller
recorder *MockMultiConnMockRecorder
isgomock struct{}
}
// MockMultiConnMockRecorder is the mock recorder for MockMultiConn.
@ -179,16 +177,16 @@ func (mr *MockMultiConnMockRecorder) IsClosed() *gomock.Call {
}
// Open mocks base method.
func (m *MockMultiConn) Open(ctx context.Context) (net.Conn, error) {
func (m *MockMultiConn) Open(arg0 context.Context) (net.Conn, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Open", ctx)
ret := m.ctrl.Call(m, "Open", arg0)
ret0, _ := ret[0].(net.Conn)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Open indicates an expected call of Open.
func (mr *MockMultiConnMockRecorder) Open(ctx any) *gomock.Call {
func (mr *MockMultiConnMockRecorder) Open(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockMultiConn)(nil).Open), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockMultiConn)(nil).Open), arg0)
}

25
node/nodeclient/mock_nodeclient/mock_nodeclient.go
View file

@ -22,7 +22,6 @@ import (
type MockNodeClient struct {
ctrl *gomock.Controller
recorder *MockNodeClientMockRecorder
isgomock struct{}
}
// MockNodeClientMockRecorder is the mock recorder for MockNodeClient.
@ -43,47 +42,47 @@ func (m *MockNodeClient) EXPECT() *MockNodeClientMockRecorder {
}
// AclAddRecord mocks base method.
func (m *MockNodeClient) AclAddRecord(ctx context.Context, spaceId string, rec *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
func (m *MockNodeClient) AclAddRecord(arg0 context.Context, arg1 string, arg2 *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclAddRecord", ctx, spaceId, rec)
ret := m.ctrl.Call(m, "AclAddRecord", arg0, arg1, arg2)
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclAddRecord indicates an expected call of AclAddRecord.
func (mr *MockNodeClientMockRecorder) AclAddRecord(ctx, spaceId, rec any) *gomock.Call {
func (mr *MockNodeClientMockRecorder) AclAddRecord(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclAddRecord", reflect.TypeOf((*MockNodeClient)(nil).AclAddRecord), ctx, spaceId, rec)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclAddRecord", reflect.TypeOf((*MockNodeClient)(nil).AclAddRecord), arg0, arg1, arg2)
}
// AclGetRecords mocks base method.
func (m *MockNodeClient) AclGetRecords(ctx context.Context, spaceId, aclHead string) ([]*consensusproto.RawRecordWithId, error) {
func (m *MockNodeClient) AclGetRecords(arg0 context.Context, arg1, arg2 string) ([]*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AclGetRecords", ctx, spaceId, aclHead)
ret := m.ctrl.Call(m, "AclGetRecords", arg0, arg1, arg2)
ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AclGetRecords indicates an expected call of AclGetRecords.
func (mr *MockNodeClientMockRecorder) AclGetRecords(ctx, spaceId, aclHead any) *gomock.Call {
func (mr *MockNodeClientMockRecorder) AclGetRecords(arg0, arg1, arg2 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockNodeClient)(nil).AclGetRecords), ctx, spaceId, aclHead)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclGetRecords", reflect.TypeOf((*MockNodeClient)(nil).AclGetRecords), arg0, arg1, arg2)
}
// Init mocks base method.
func (m *MockNodeClient) Init(a *app.App) error {
func (m *MockNodeClient) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockNodeClientMockRecorder) Init(a any) *gomock.Call {
func (mr *MockNodeClientMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockNodeClient)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockNodeClient)(nil).Init), arg0)
}
// Name mocks base method.

65
nodeconf/mock_nodeconf/mock_nodeconf.go
View file

@ -23,7 +23,6 @@ import (
type MockService struct {
ctrl *gomock.Controller
recorder *MockServiceMockRecorder
isgomock struct{}
}
// MockServiceMockRecorder is the mock recorder for MockService.
@ -58,17 +57,17 @@ func (mr *MockServiceMockRecorder) CHash() *gomock.Call {
}
// Close mocks base method.
func (m *MockService) Close(ctx context.Context) error {
func (m *MockService) Close(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", ctx)
ret := m.ctrl.Call(m, "Close", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockServiceMockRecorder) Close(ctx any) *gomock.Call {
func (mr *MockServiceMockRecorder) Close(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockService)(nil).Close), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockService)(nil).Close), arg0)
}
// Configuration mocks base method.
@ -142,31 +141,31 @@ func (mr *MockServiceMockRecorder) Id() *gomock.Call {
}
// Init mocks base method.
func (m *MockService) Init(a *app.App) error {
func (m *MockService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), arg0)
}
// IsResponsible mocks base method.
func (m *MockService) IsResponsible(spaceId string) bool {
func (m *MockService) IsResponsible(arg0 string) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsResponsible", spaceId)
ret := m.ctrl.Call(m, "IsResponsible", arg0)
ret0, _ := ret[0].(bool)
return ret0
}
// IsResponsible indicates an expected call of IsResponsible.
func (mr *MockServiceMockRecorder) IsResponsible(spaceId any) *gomock.Call {
func (mr *MockServiceMockRecorder) IsResponsible(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResponsible", reflect.TypeOf((*MockService)(nil).IsResponsible), spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResponsible", reflect.TypeOf((*MockService)(nil).IsResponsible), arg0)
}
// Name mocks base method.
@ -212,45 +211,45 @@ func (mr *MockServiceMockRecorder) NetworkCompatibilityStatus() *gomock.Call {
}
// NodeIds mocks base method.
func (m *MockService) NodeIds(spaceId string) []string {
func (m *MockService) NodeIds(arg0 string) []string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeIds", spaceId)
ret := m.ctrl.Call(m, "NodeIds", arg0)
ret0, _ := ret[0].([]string)
return ret0
}
// NodeIds indicates an expected call of NodeIds.
func (mr *MockServiceMockRecorder) NodeIds(spaceId any) *gomock.Call {
func (mr *MockServiceMockRecorder) NodeIds(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeIds", reflect.TypeOf((*MockService)(nil).NodeIds), spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeIds", reflect.TypeOf((*MockService)(nil).NodeIds), arg0)
}
// NodeTypes mocks base method.
func (m *MockService) NodeTypes(nodeId string) []nodeconf.NodeType {
func (m *MockService) NodeTypes(arg0 string) []nodeconf.NodeType {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeTypes", nodeId)
ret := m.ctrl.Call(m, "NodeTypes", arg0)
ret0, _ := ret[0].([]nodeconf.NodeType)
return ret0
}
// NodeTypes indicates an expected call of NodeTypes.
func (mr *MockServiceMockRecorder) NodeTypes(nodeId any) *gomock.Call {
func (mr *MockServiceMockRecorder) NodeTypes(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeTypes", reflect.TypeOf((*MockService)(nil).NodeTypes), nodeId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeTypes", reflect.TypeOf((*MockService)(nil).NodeTypes), arg0)
}
// Partition mocks base method.
func (m *MockService) Partition(spaceId string) int {
func (m *MockService) Partition(arg0 string) int {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Partition", spaceId)
ret := m.ctrl.Call(m, "Partition", arg0)
ret0, _ := ret[0].(int)
return ret0
}
// Partition indicates an expected call of Partition.
func (mr *MockServiceMockRecorder) Partition(spaceId any) *gomock.Call {
func (mr *MockServiceMockRecorder) Partition(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Partition", reflect.TypeOf((*MockService)(nil).Partition), spaceId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Partition", reflect.TypeOf((*MockService)(nil).Partition), arg0)
}
// PaymentProcessingNodePeers mocks base method.
@ -268,30 +267,30 @@ func (mr *MockServiceMockRecorder) PaymentProcessingNodePeers() *gomock.Call {
}
// PeerAddresses mocks base method.
func (m *MockService) PeerAddresses(peerId string) ([]string, bool) {
func (m *MockService) PeerAddresses(arg0 string) ([]string, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PeerAddresses", peerId)
ret := m.ctrl.Call(m, "PeerAddresses", arg0)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// PeerAddresses indicates an expected call of PeerAddresses.
func (mr *MockServiceMockRecorder) PeerAddresses(peerId any) *gomock.Call {
func (mr *MockServiceMockRecorder) PeerAddresses(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerAddresses", reflect.TypeOf((*MockService)(nil).PeerAddresses), peerId)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerAddresses", reflect.TypeOf((*MockService)(nil).PeerAddresses), arg0)
}
// Run mocks base method.
func (m *MockService) Run(ctx context.Context) error {
func (m *MockService) Run(arg0 context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", ctx)
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockServiceMockRecorder) Run(ctx any) *gomock.Call {
func (mr *MockServiceMockRecorder) Run(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockService)(nil).Run), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockService)(nil).Run), arg0)
}

81
paymentservice/paymentserviceclient/mock/mock_paymentserviceclient.go
View file

@ -22,7 +22,6 @@ import (
type MockAnyPpClientService struct {
ctrl *gomock.Controller
recorder *MockAnyPpClientServiceMockRecorder
isgomock struct{}
}
// MockAnyPpClientServiceMockRecorder is the mock recorder for MockAnyPpClientService.
@ -43,122 +42,122 @@ func (m *MockAnyPpClientService) EXPECT() *MockAnyPpClientServiceMockRecorder {
}
// BuySubscription mocks base method.
func (m *MockAnyPpClientService) BuySubscription(ctx context.Context, in *paymentserviceproto.BuySubscriptionRequestSigned) (*paymentserviceproto.BuySubscriptionResponse, error) {
func (m *MockAnyPpClientService) BuySubscription(arg0 context.Context, arg1 *paymentserviceproto.BuySubscriptionRequestSigned) (*paymentserviceproto.BuySubscriptionResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BuySubscription", ctx, in)
ret := m.ctrl.Call(m, "BuySubscription", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.BuySubscriptionResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BuySubscription indicates an expected call of BuySubscription.
func (mr *MockAnyPpClientServiceMockRecorder) BuySubscription(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) BuySubscription(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuySubscription", reflect.TypeOf((*MockAnyPpClientService)(nil).BuySubscription), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuySubscription", reflect.TypeOf((*MockAnyPpClientService)(nil).BuySubscription), arg0, arg1)
}
// FinalizeSubscription mocks base method.
func (m *MockAnyPpClientService) FinalizeSubscription(ctx context.Context, in *paymentserviceproto.FinalizeSubscriptionRequestSigned) (*paymentserviceproto.FinalizeSubscriptionResponse, error) {
func (m *MockAnyPpClientService) FinalizeSubscription(arg0 context.Context, arg1 *paymentserviceproto.FinalizeSubscriptionRequestSigned) (*paymentserviceproto.FinalizeSubscriptionResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FinalizeSubscription", ctx, in)
ret := m.ctrl.Call(m, "FinalizeSubscription", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.FinalizeSubscriptionResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// FinalizeSubscription indicates an expected call of FinalizeSubscription.
func (mr *MockAnyPpClientServiceMockRecorder) FinalizeSubscription(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) FinalizeSubscription(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeSubscription", reflect.TypeOf((*MockAnyPpClientService)(nil).FinalizeSubscription), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeSubscription", reflect.TypeOf((*MockAnyPpClientService)(nil).FinalizeSubscription), arg0, arg1)
}
// GetAllTiers mocks base method.
func (m *MockAnyPpClientService) GetAllTiers(ctx context.Context, in *paymentserviceproto.GetTiersRequestSigned) (*paymentserviceproto.GetTiersResponse, error) {
func (m *MockAnyPpClientService) GetAllTiers(arg0 context.Context, arg1 *paymentserviceproto.GetTiersRequestSigned) (*paymentserviceproto.GetTiersResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAllTiers", ctx, in)
ret := m.ctrl.Call(m, "GetAllTiers", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.GetTiersResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAllTiers indicates an expected call of GetAllTiers.
func (mr *MockAnyPpClientServiceMockRecorder) GetAllTiers(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) GetAllTiers(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllTiers", reflect.TypeOf((*MockAnyPpClientService)(nil).GetAllTiers), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllTiers", reflect.TypeOf((*MockAnyPpClientService)(nil).GetAllTiers), arg0, arg1)
}
// GetSubscriptionPortalLink mocks base method.
func (m *MockAnyPpClientService) GetSubscriptionPortalLink(ctx context.Context, in *paymentserviceproto.GetSubscriptionPortalLinkRequestSigned) (*paymentserviceproto.GetSubscriptionPortalLinkResponse, error) {
func (m *MockAnyPpClientService) GetSubscriptionPortalLink(arg0 context.Context, arg1 *paymentserviceproto.GetSubscriptionPortalLinkRequestSigned) (*paymentserviceproto.GetSubscriptionPortalLinkResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSubscriptionPortalLink", ctx, in)
ret := m.ctrl.Call(m, "GetSubscriptionPortalLink", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.GetSubscriptionPortalLinkResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetSubscriptionPortalLink indicates an expected call of GetSubscriptionPortalLink.
func (mr *MockAnyPpClientServiceMockRecorder) GetSubscriptionPortalLink(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) GetSubscriptionPortalLink(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionPortalLink", reflect.TypeOf((*MockAnyPpClientService)(nil).GetSubscriptionPortalLink), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionPortalLink", reflect.TypeOf((*MockAnyPpClientService)(nil).GetSubscriptionPortalLink), arg0, arg1)
}
// GetSubscriptionStatus mocks base method.
func (m *MockAnyPpClientService) GetSubscriptionStatus(ctx context.Context, in *paymentserviceproto.GetSubscriptionRequestSigned) (*paymentserviceproto.GetSubscriptionResponse, error) {
func (m *MockAnyPpClientService) GetSubscriptionStatus(arg0 context.Context, arg1 *paymentserviceproto.GetSubscriptionRequestSigned) (*paymentserviceproto.GetSubscriptionResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSubscriptionStatus", ctx, in)
ret := m.ctrl.Call(m, "GetSubscriptionStatus", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.GetSubscriptionResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetSubscriptionStatus indicates an expected call of GetSubscriptionStatus.
func (mr *MockAnyPpClientServiceMockRecorder) GetSubscriptionStatus(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) GetSubscriptionStatus(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionStatus", reflect.TypeOf((*MockAnyPpClientService)(nil).GetSubscriptionStatus), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionStatus", reflect.TypeOf((*MockAnyPpClientService)(nil).GetSubscriptionStatus), arg0, arg1)
}
// GetVerificationEmail mocks base method.
func (m *MockAnyPpClientService) GetVerificationEmail(ctx context.Context, in *paymentserviceproto.GetVerificationEmailRequestSigned) (*paymentserviceproto.GetVerificationEmailResponse, error) {
func (m *MockAnyPpClientService) GetVerificationEmail(arg0 context.Context, arg1 *paymentserviceproto.GetVerificationEmailRequestSigned) (*paymentserviceproto.GetVerificationEmailResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetVerificationEmail", ctx, in)
ret := m.ctrl.Call(m, "GetVerificationEmail", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.GetVerificationEmailResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetVerificationEmail indicates an expected call of GetVerificationEmail.
func (mr *MockAnyPpClientServiceMockRecorder) GetVerificationEmail(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) GetVerificationEmail(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerificationEmail", reflect.TypeOf((*MockAnyPpClientService)(nil).GetVerificationEmail), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerificationEmail", reflect.TypeOf((*MockAnyPpClientService)(nil).GetVerificationEmail), arg0, arg1)
}
// Init mocks base method.
func (m *MockAnyPpClientService) Init(a *app.App) error {
func (m *MockAnyPpClientService) Init(arg0 *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", a)
ret := m.ctrl.Call(m, "Init", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockAnyPpClientServiceMockRecorder) Init(a any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) Init(arg0 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAnyPpClientService)(nil).Init), a)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAnyPpClientService)(nil).Init), arg0)
}
// IsNameValid mocks base method.
func (m *MockAnyPpClientService) IsNameValid(ctx context.Context, in *paymentserviceproto.IsNameValidRequest) (*paymentserviceproto.IsNameValidResponse, error) {
func (m *MockAnyPpClientService) IsNameValid(arg0 context.Context, arg1 *paymentserviceproto.IsNameValidRequest) (*paymentserviceproto.IsNameValidResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsNameValid", ctx, in)
ret := m.ctrl.Call(m, "IsNameValid", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.IsNameValidResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// IsNameValid indicates an expected call of IsNameValid.
func (mr *MockAnyPpClientServiceMockRecorder) IsNameValid(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) IsNameValid(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNameValid", reflect.TypeOf((*MockAnyPpClientService)(nil).IsNameValid), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNameValid", reflect.TypeOf((*MockAnyPpClientService)(nil).IsNameValid), arg0, arg1)
}
// Name mocks base method.
@ -176,31 +175,31 @@ func (mr *MockAnyPpClientServiceMockRecorder) Name() *gomock.Call {
}
// VerifyAppStoreReceipt mocks base method.
func (m *MockAnyPpClientService) VerifyAppStoreReceipt(ctx context.Context, in *paymentserviceproto.VerifyAppStoreReceiptRequestSigned) (*paymentserviceproto.VerifyAppStoreReceiptResponse, error) {
func (m *MockAnyPpClientService) VerifyAppStoreReceipt(arg0 context.Context, arg1 *paymentserviceproto.VerifyAppStoreReceiptRequestSigned) (*paymentserviceproto.VerifyAppStoreReceiptResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "VerifyAppStoreReceipt", ctx, in)
ret := m.ctrl.Call(m, "VerifyAppStoreReceipt", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.VerifyAppStoreReceiptResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// VerifyAppStoreReceipt indicates an expected call of VerifyAppStoreReceipt.
func (mr *MockAnyPpClientServiceMockRecorder) VerifyAppStoreReceipt(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) VerifyAppStoreReceipt(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAppStoreReceipt", reflect.TypeOf((*MockAnyPpClientService)(nil).VerifyAppStoreReceipt), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAppStoreReceipt", reflect.TypeOf((*MockAnyPpClientService)(nil).VerifyAppStoreReceipt), arg0, arg1)
}
// VerifyEmail mocks base method.
func (m *MockAnyPpClientService) VerifyEmail(ctx context.Context, in *paymentserviceproto.VerifyEmailRequestSigned) (*paymentserviceproto.VerifyEmailResponse, error) {
func (m *MockAnyPpClientService) VerifyEmail(arg0 context.Context, arg1 *paymentserviceproto.VerifyEmailRequestSigned) (*paymentserviceproto.VerifyEmailResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "VerifyEmail", ctx, in)
ret := m.ctrl.Call(m, "VerifyEmail", arg0, arg1)
ret0, _ := ret[0].(*paymentserviceproto.VerifyEmailResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// VerifyEmail indicates an expected call of VerifyEmail.
func (mr *MockAnyPpClientServiceMockRecorder) VerifyEmail(ctx, in any) *gomock.Call {
func (mr *MockAnyPpClientServiceMockRecorder) VerifyEmail(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyEmail", reflect.TypeOf((*MockAnyPpClientService)(nil).VerifyEmail), ctx, in)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyEmail", reflect.TypeOf((*MockAnyPpClientService)(nil).VerifyEmail), arg0, arg1)
}

1
util/periodicsync/mock_periodicsync/mock_periodicsync.go
View file

@ -19,7 +19,6 @@ import (
type MockPeriodicSync struct {
ctrl *gomock.Controller
recorder *MockPeriodicSyncMockRecorder
isgomock struct{}
}
// MockPeriodicSyncMockRecorder is the mock recorder for MockPeriodicSync.