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

Add mocks target to Makefile, regenerate mocks

Browse source
This commit is contained in:
Anthony Akentiev 2024-10-26 18:48:47 +01:00
parent a7df2dbf1d
commit 4338440bed
No known key found for this signature in database
GPG key ID: 017A11DC01A79831
38 changed files with 1168 additions and 1114 deletions
Download patch file Download diff file Expand all files Collapse all files

9
Makefile
View file

@ -1,4 +1,4 @@
.PHONY: proto test deps
.PHONY: proto test deps mocks
export GOPRIVATE=github.com/anyproto
export PATH:=deps:$(PATH)
@ -32,12 +32,17 @@ proto-execute:
protoc --gogofaster_out=:. --go-drpc_out=protolib=github.com/gogo/protobuf:. nameservice/nameserviceproto/protos/*.proto
protoc --gogofaster_out=:. --go-drpc_out=protolib=github.com/gogo/protobuf:. paymentservice/paymentserviceproto/protos/*.proto
mocks:
echo 'Generating mocks...'
go build -o deps go.uber.org/mock/mockgen
PATH=$(CURDIR)/deps:$(PATH) go generate ./...
deps:
go mod download
go build -o deps storj.io/drpc/cmd/protoc-gen-go-drpc
go build -o deps github.com/anyproto/protobuf/protoc-gen-gogofaster
test:
test: mocks
go test ./... --cover
replace-gogo-strings:

9
accountservice/mock_accountservice/mock_accountservice.go
View file

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

73
acl/mock_acl/mock_acl.go
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

65
commonspace/mock_commonspace/mock_commonspace.go
View file

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

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

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

25
commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go
View file

@ -21,6 +21,7 @@ import (
type MockListStorage struct {
ctrl *gomock.Controller
recorder *MockListStorageMockRecorder
isgomock struct{}
}
// MockListStorageMockRecorder is the mock recorder for MockListStorage.
@ -41,32 +42,32 @@ func (m *MockListStorage) EXPECT() *MockListStorageMockRecorder {
}
// AddRawRecord mocks base method.
func (m *MockListStorage) AddRawRecord(arg0 context.Context, arg1 *consensusproto.RawRecordWithId) error {
func (m *MockListStorage) AddRawRecord(ctx context.Context, rec *consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecord", arg0, arg1)
ret := m.ctrl.Call(m, "AddRawRecord", ctx, rec)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecord indicates an expected call of AddRawRecord.
func (mr *MockListStorageMockRecorder) AddRawRecord(arg0, arg1 any) *gomock.Call {
func (mr *MockListStorageMockRecorder) AddRawRecord(ctx, rec any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockListStorage)(nil).AddRawRecord), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockListStorage)(nil).AddRawRecord), ctx, rec)
}
// GetRawRecord mocks base method.
func (m *MockListStorage) GetRawRecord(arg0 context.Context, arg1 string) (*consensusproto.RawRecordWithId, error) {
func (m *MockListStorage) GetRawRecord(ctx context.Context, id string) (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawRecord", arg0, arg1)
ret := m.ctrl.Call(m, "GetRawRecord", ctx, id)
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawRecord indicates an expected call of GetRawRecord.
func (mr *MockListStorageMockRecorder) GetRawRecord(arg0, arg1 any) *gomock.Call {
func (mr *MockListStorageMockRecorder) GetRawRecord(ctx, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawRecord", reflect.TypeOf((*MockListStorage)(nil).GetRawRecord), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawRecord", reflect.TypeOf((*MockListStorage)(nil).GetRawRecord), ctx, id)
}
// Head mocks base method.
@ -114,15 +115,15 @@ func (mr *MockListStorageMockRecorder) Root() *gomock.Call {
}
// SetHead mocks base method.
func (m *MockListStorage) SetHead(arg0 string) error {
func (m *MockListStorage) SetHead(headId string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHead", arg0)
ret := m.ctrl.Call(m, "SetHead", headId)
ret0, _ := ret[0].(error)
return ret0
}
// SetHead indicates an expected call of SetHead.
func (mr *MockListStorageMockRecorder) SetHead(arg0 any) *gomock.Call {
func (mr *MockListStorageMockRecorder) SetHead(headId any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockListStorage)(nil).SetHead), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockListStorage)(nil).SetHead), headId)
}

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

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

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

@ -25,6 +25,7 @@ import (
type MockObjectTree struct {
ctrl *gomock.Controller
recorder *MockObjectTreeMockRecorder
isgomock struct{}
}
// MockObjectTreeMockRecorder is the mock recorder for MockObjectTree.
@ -59,63 +60,63 @@ func (mr *MockObjectTreeMockRecorder) AclList() *gomock.Call {
}
// AddContent mocks base method.
func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddContent(ctx context.Context, content objecttree.SignableChangeContent) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
ret := m.ctrl.Call(m, "AddContent", ctx, content)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddContent indicates an expected call of AddContent.
func (mr *MockObjectTreeMockRecorder) AddContent(arg0, arg1 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddContent(ctx, content any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockObjectTree)(nil).AddContent), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockObjectTree)(nil).AddContent), ctx, content)
}
// AddContentWithValidator mocks base method.
func (m *MockObjectTree) AddContentWithValidator(arg0 context.Context, arg1 objecttree.SignableChangeContent, arg2 func(*treechangeproto.RawTreeChangeWithId) error) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddContentWithValidator(ctx context.Context, content objecttree.SignableChangeContent, validate func(*treechangeproto.RawTreeChangeWithId) error) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContentWithValidator", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "AddContentWithValidator", ctx, content, validate)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddContentWithValidator indicates an expected call of AddContentWithValidator.
func (mr *MockObjectTreeMockRecorder) AddContentWithValidator(arg0, arg1, arg2 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddContentWithValidator(ctx, content, validate any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContentWithValidator", reflect.TypeOf((*MockObjectTree)(nil).AddContentWithValidator), arg0, arg1, arg2)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContentWithValidator", reflect.TypeOf((*MockObjectTree)(nil).AddContentWithValidator), ctx, content, validate)
}
// AddRawChanges mocks base method.
func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddRawChanges(ctx context.Context, changes objecttree.RawChangesPayload) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
ret := m.ctrl.Call(m, "AddRawChanges", ctx, changes)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChanges indicates an expected call of AddRawChanges.
func (mr *MockObjectTreeMockRecorder) AddRawChanges(arg0, arg1 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddRawChanges(ctx, changes any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockObjectTree)(nil).AddRawChanges), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockObjectTree)(nil).AddRawChanges), ctx, changes)
}
// AddRawChangesWithUpdater mocks base method.
func (m *MockObjectTree) AddRawChangesWithUpdater(arg0 context.Context, arg1 objecttree.RawChangesPayload, arg2 func(objecttree.ObjectTree, objecttree.Mode) error) (objecttree.AddResult, error) {
func (m *MockObjectTree) AddRawChangesWithUpdater(ctx context.Context, changes objecttree.RawChangesPayload, updater func(objecttree.ObjectTree, objecttree.Mode) error) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChangesWithUpdater", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "AddRawChangesWithUpdater", ctx, changes, updater)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddRawChangesWithUpdater indicates an expected call of AddRawChangesWithUpdater.
func (mr *MockObjectTreeMockRecorder) AddRawChangesWithUpdater(arg0, arg1, arg2 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) AddRawChangesWithUpdater(ctx, changes, updater any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesWithUpdater", reflect.TypeOf((*MockObjectTree)(nil).AddRawChangesWithUpdater), arg0, arg1, arg2)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesWithUpdater", reflect.TypeOf((*MockObjectTree)(nil).AddRawChangesWithUpdater), ctx, changes, updater)
}
// ChangeInfo mocks base method.
@ -133,33 +134,33 @@ func (mr *MockObjectTreeMockRecorder) ChangeInfo() *gomock.Call {
}
// ChangesAfterCommonSnapshot mocks base method.
func (m *MockObjectTree) ChangesAfterCommonSnapshot(arg0, arg1 []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockObjectTree) ChangesAfterCommonSnapshot(snapshotPath, heads []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshot", arg0, arg1)
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(arg0, arg1 any) *gomock.Call {
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), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshot", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshot), snapshotPath, heads)
}
// ChangesAfterCommonSnapshotLoader mocks base method.
func (m *MockObjectTree) ChangesAfterCommonSnapshotLoader(arg0, arg1 []string) (objecttree.LoadIterator, error) {
func (m *MockObjectTree) ChangesAfterCommonSnapshotLoader(snapshotPath, heads []string) (objecttree.LoadIterator, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshotLoader", arg0, arg1)
ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshotLoader", snapshotPath, heads)
ret0, _ := ret[0].(objecttree.LoadIterator)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChangesAfterCommonSnapshotLoader indicates an expected call of ChangesAfterCommonSnapshotLoader.
func (mr *MockObjectTreeMockRecorder) ChangesAfterCommonSnapshotLoader(arg0, arg1 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) ChangesAfterCommonSnapshotLoader(snapshotPath, heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshotLoader", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshotLoader), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshotLoader", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshotLoader), snapshotPath, heads)
}
// Close mocks base method.
@ -177,18 +178,18 @@ func (mr *MockObjectTreeMockRecorder) Close() *gomock.Call {
}
// Debug mocks base method.
func (m *MockObjectTree) Debug(arg0 objecttree.DescriptionParser) (objecttree.DebugInfo, error) {
func (m *MockObjectTree) Debug(parser objecttree.DescriptionParser) (objecttree.DebugInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Debug", arg0)
ret := m.ctrl.Call(m, "Debug", parser)
ret0, _ := ret[0].(objecttree.DebugInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Debug indicates an expected call of Debug.
func (mr *MockObjectTreeMockRecorder) Debug(arg0 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) Debug(parser any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockObjectTree)(nil).Debug), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockObjectTree)(nil).Debug), parser)
}
// Delete mocks base method.
@ -295,31 +296,31 @@ func (mr *MockObjectTreeMockRecorder) IsDerived() *gomock.Call {
}
// IterateFrom mocks base method.
func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func(*objecttree.Change, []byte) (any, error), arg2 func(*objecttree.Change) bool) error {
func (m *MockObjectTree) IterateFrom(id string, convert func(*objecttree.Change, []byte) (any, error), iterate func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "IterateFrom", id, convert, iterate)
ret0, _ := ret[0].(error)
return ret0
}
// IterateFrom indicates an expected call of IterateFrom.
func (mr *MockObjectTreeMockRecorder) IterateFrom(arg0, arg1, arg2 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) IterateFrom(id, convert, iterate any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockObjectTree)(nil).IterateFrom), arg0, arg1, arg2)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockObjectTree)(nil).IterateFrom), id, convert, iterate)
}
// IterateRoot mocks base method.
func (m *MockObjectTree) IterateRoot(arg0 func(*objecttree.Change, []byte) (any, error), arg1 func(*objecttree.Change) bool) error {
func (m *MockObjectTree) IterateRoot(convert func(*objecttree.Change, []byte) (any, error), iterate func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateRoot", arg0, arg1)
ret := m.ctrl.Call(m, "IterateRoot", convert, iterate)
ret0, _ := ret[0].(error)
return ret0
}
// IterateRoot indicates an expected call of IterateRoot.
func (mr *MockObjectTreeMockRecorder) IterateRoot(arg0, arg1 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) IterateRoot(convert, iterate any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockObjectTree)(nil).IterateRoot), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockObjectTree)(nil).IterateRoot), convert, iterate)
}
// Len mocks base method.
@ -349,18 +350,18 @@ func (mr *MockObjectTreeMockRecorder) Lock() *gomock.Call {
}
// PrepareChange mocks base method.
func (m *MockObjectTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockObjectTree) PrepareChange(content objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PrepareChange", arg0)
ret := m.ctrl.Call(m, "PrepareChange", content)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PrepareChange indicates an expected call of PrepareChange.
func (mr *MockObjectTreeMockRecorder) PrepareChange(arg0 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) PrepareChange(content any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockObjectTree)(nil).PrepareChange), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockObjectTree)(nil).PrepareChange), content)
}
// Root mocks base method.
@ -378,15 +379,15 @@ func (mr *MockObjectTreeMockRecorder) Root() *gomock.Call {
}
// SetFlusher mocks base method.
func (m *MockObjectTree) SetFlusher(arg0 objecttree.Flusher) {
func (m *MockObjectTree) SetFlusher(flusher objecttree.Flusher) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetFlusher", arg0)
m.ctrl.Call(m, "SetFlusher", flusher)
}
// SetFlusher indicates an expected call of SetFlusher.
func (mr *MockObjectTreeMockRecorder) SetFlusher(arg0 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) SetFlusher(flusher any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlusher", reflect.TypeOf((*MockObjectTree)(nil).SetFlusher), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlusher", reflect.TypeOf((*MockObjectTree)(nil).SetFlusher), flusher)
}
// SnapshotPath mocks base method.
@ -418,18 +419,18 @@ func (mr *MockObjectTreeMockRecorder) Storage() *gomock.Call {
}
// TryClose mocks base method.
func (m *MockObjectTree) TryClose(arg0 time.Duration) (bool, error) {
func (m *MockObjectTree) TryClose(objectTTL time.Duration) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TryClose", arg0)
ret := m.ctrl.Call(m, "TryClose", objectTTL)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TryClose indicates an expected call of TryClose.
func (mr *MockObjectTreeMockRecorder) TryClose(arg0 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) TryClose(objectTTL any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockObjectTree)(nil).TryClose), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockObjectTree)(nil).TryClose), objectTTL)
}
// TryLock mocks base method.
@ -473,16 +474,16 @@ func (mr *MockObjectTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
}
// UnpackChange mocks base method.
func (m *MockObjectTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
func (m *MockObjectTree) UnpackChange(raw *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UnpackChange", arg0)
ret := m.ctrl.Call(m, "UnpackChange", raw)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UnpackChange indicates an expected call of UnpackChange.
func (mr *MockObjectTreeMockRecorder) UnpackChange(arg0 any) *gomock.Call {
func (mr *MockObjectTreeMockRecorder) UnpackChange(raw any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockObjectTree)(nil).UnpackChange), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockObjectTree)(nil).UnpackChange), raw)
}

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

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

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

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

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

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

49
commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go
View file

@ -21,6 +21,7 @@ import (
type MockTreeStorage struct {
ctrl *gomock.Controller
recorder *MockTreeStorageMockRecorder
isgomock struct{}
}
// MockTreeStorageMockRecorder is the mock recorder for MockTreeStorage.
@ -41,31 +42,31 @@ func (m *MockTreeStorage) EXPECT() *MockTreeStorageMockRecorder {
}
// AddRawChange mocks base method.
func (m *MockTreeStorage) AddRawChange(arg0 *treechangeproto.RawTreeChangeWithId) error {
func (m *MockTreeStorage) AddRawChange(change *treechangeproto.RawTreeChangeWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChange", arg0)
ret := m.ctrl.Call(m, "AddRawChange", change)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawChange indicates an expected call of AddRawChange.
func (mr *MockTreeStorageMockRecorder) AddRawChange(arg0 any) *gomock.Call {
func (mr *MockTreeStorageMockRecorder) AddRawChange(change any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChange", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChange), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChange", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChange), change)
}
// AddRawChangesSetHeads mocks base method.
func (m *MockTreeStorage) AddRawChangesSetHeads(arg0 []*treechangeproto.RawTreeChangeWithId, arg1 []string) error {
func (m *MockTreeStorage) AddRawChangesSetHeads(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChangesSetHeads", arg0, arg1)
ret := m.ctrl.Call(m, "AddRawChangesSetHeads", changes, heads)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawChangesSetHeads indicates an expected call of AddRawChangesSetHeads.
func (mr *MockTreeStorageMockRecorder) AddRawChangesSetHeads(arg0, arg1 any) *gomock.Call {
func (mr *MockTreeStorageMockRecorder) AddRawChangesSetHeads(changes, heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesSetHeads", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChangesSetHeads), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesSetHeads", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChangesSetHeads), changes, heads)
}
// Delete mocks base method.
@ -98,48 +99,48 @@ func (mr *MockTreeStorageMockRecorder) GetAllChangeIds() *gomock.Call {
}
// GetAppendRawChange mocks base method.
func (m *MockTreeStorage) GetAppendRawChange(arg0 context.Context, arg1 []byte, arg2 string) (*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockTreeStorage) GetAppendRawChange(ctx context.Context, buf []byte, id string) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAppendRawChange", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "GetAppendRawChange", ctx, buf, id)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAppendRawChange indicates an expected call of GetAppendRawChange.
func (mr *MockTreeStorageMockRecorder) GetAppendRawChange(arg0, arg1, arg2 any) *gomock.Call {
func (mr *MockTreeStorageMockRecorder) GetAppendRawChange(ctx, buf, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppendRawChange", reflect.TypeOf((*MockTreeStorage)(nil).GetAppendRawChange), arg0, arg1, arg2)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppendRawChange", reflect.TypeOf((*MockTreeStorage)(nil).GetAppendRawChange), ctx, buf, id)
}
// GetRawChange mocks base method.
func (m *MockTreeStorage) GetRawChange(arg0 context.Context, arg1 string) (*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockTreeStorage) GetRawChange(ctx context.Context, id string) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawChange", arg0, arg1)
ret := m.ctrl.Call(m, "GetRawChange", ctx, id)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawChange indicates an expected call of GetRawChange.
func (mr *MockTreeStorageMockRecorder) GetRawChange(arg0, arg1 any) *gomock.Call {
func (mr *MockTreeStorageMockRecorder) GetRawChange(ctx, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawChange", reflect.TypeOf((*MockTreeStorage)(nil).GetRawChange), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawChange", reflect.TypeOf((*MockTreeStorage)(nil).GetRawChange), ctx, id)
}
// HasChange mocks base method.
func (m *MockTreeStorage) HasChange(arg0 context.Context, arg1 string) (bool, error) {
func (m *MockTreeStorage) HasChange(ctx context.Context, id string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasChange", arg0, arg1)
ret := m.ctrl.Call(m, "HasChange", ctx, id)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HasChange indicates an expected call of HasChange.
func (mr *MockTreeStorageMockRecorder) HasChange(arg0, arg1 any) *gomock.Call {
func (mr *MockTreeStorageMockRecorder) HasChange(ctx, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasChange", reflect.TypeOf((*MockTreeStorage)(nil).HasChange), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasChange", reflect.TypeOf((*MockTreeStorage)(nil).HasChange), ctx, id)
}
// Heads mocks base method.
@ -187,15 +188,15 @@ func (mr *MockTreeStorageMockRecorder) Root() *gomock.Call {
}
// SetHeads mocks base method.
func (m *MockTreeStorage) SetHeads(arg0 []string) error {
func (m *MockTreeStorage) SetHeads(heads []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeads", arg0)
ret := m.ctrl.Call(m, "SetHeads", heads)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeads indicates an expected call of SetHeads.
func (mr *MockTreeStorageMockRecorder) SetHeads(arg0 any) *gomock.Call {
func (mr *MockTreeStorageMockRecorder) SetHeads(heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeads", reflect.TypeOf((*MockTreeStorage)(nil).SetHeads), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeads", reflect.TypeOf((*MockTreeStorage)(nil).SetHeads), heads)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -25,6 +25,7 @@ import (
type MockSpaceStorage struct {
ctrl *gomock.Controller
recorder *MockSpaceStorageMockRecorder
isgomock struct{}
}
// MockSpaceStorageMockRecorder is the mock recorder for MockSpaceStorage.
@ -60,47 +61,47 @@ func (mr *MockSpaceStorageMockRecorder) AclStorage() *gomock.Call {
}
// Close mocks base method.
func (m *MockSpaceStorage) Close(arg0 context.Context) error {
func (m *MockSpaceStorage) Close(ctx context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Close", arg0)
ret := m.ctrl.Call(m, "Close", ctx)
ret0, _ := ret[0].(error)
return ret0
}
// Close indicates an expected call of Close.
func (mr *MockSpaceStorageMockRecorder) Close(arg0 any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) Close(ctx any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceStorage)(nil).Close), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceStorage)(nil).Close), ctx)
}
// CreateTreeStorage mocks base method.
func (m *MockSpaceStorage) CreateTreeStorage(arg0 treestorage.TreeStorageCreatePayload) (treestorage.TreeStorage, error) {
func (m *MockSpaceStorage) CreateTreeStorage(payload treestorage.TreeStorageCreatePayload) (treestorage.TreeStorage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateTreeStorage", arg0)
ret := m.ctrl.Call(m, "CreateTreeStorage", payload)
ret0, _ := ret[0].(treestorage.TreeStorage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateTreeStorage indicates an expected call of CreateTreeStorage.
func (mr *MockSpaceStorageMockRecorder) CreateTreeStorage(arg0 any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) CreateTreeStorage(payload any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).CreateTreeStorage), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).CreateTreeStorage), payload)
}
// HasTree mocks base method.
func (m *MockSpaceStorage) HasTree(arg0 string) (bool, error) {
func (m *MockSpaceStorage) HasTree(id string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasTree", arg0)
ret := m.ctrl.Call(m, "HasTree", id)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HasTree indicates an expected call of HasTree.
func (mr *MockSpaceStorageMockRecorder) HasTree(arg0 any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) HasTree(id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasTree", reflect.TypeOf((*MockSpaceStorage)(nil).HasTree), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasTree", reflect.TypeOf((*MockSpaceStorage)(nil).HasTree), id)
}
// Id mocks base method.
@ -118,17 +119,17 @@ func (mr *MockSpaceStorageMockRecorder) Id() *gomock.Call {
}
// Init mocks base method.
func (m *MockSpaceStorage) Init(arg0 *app.App) error {
func (m *MockSpaceStorage) Init(a *app.App) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Init", arg0)
ret := m.ctrl.Call(m, "Init", a)
ret0, _ := ret[0].(error)
return ret0
}
// Init indicates an expected call of Init.
func (mr *MockSpaceStorageMockRecorder) Init(arg0 any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) Init(a any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceStorage)(nil).Init), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceStorage)(nil).Init), a)
}
// IsSpaceDeleted mocks base method.
@ -176,17 +177,17 @@ func (mr *MockSpaceStorageMockRecorder) ReadSpaceHash() *gomock.Call {
}
// Run mocks base method.
func (m *MockSpaceStorage) Run(arg0 context.Context) error {
func (m *MockSpaceStorage) Run(ctx context.Context) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Run", arg0)
ret := m.ctrl.Call(m, "Run", ctx)
ret0, _ := ret[0].(error)
return ret0
}
// Run indicates an expected call of Run.
func (mr *MockSpaceStorageMockRecorder) Run(arg0 any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) Run(ctx any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSpaceStorage)(nil).Run), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSpaceStorage)(nil).Run), ctx)
}
// SetSpaceDeleted mocks base method.
@ -204,17 +205,17 @@ func (mr *MockSpaceStorageMockRecorder) SetSpaceDeleted() *gomock.Call {
}
// SetTreeDeletedStatus mocks base method.
func (m *MockSpaceStorage) SetTreeDeletedStatus(arg0, arg1 string) error {
func (m *MockSpaceStorage) SetTreeDeletedStatus(id, state string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetTreeDeletedStatus", arg0, arg1)
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(arg0, arg1 any) *gomock.Call {
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), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTreeDeletedStatus", reflect.TypeOf((*MockSpaceStorage)(nil).SetTreeDeletedStatus), id, state)
}
// SpaceHeader mocks base method.
@ -262,60 +263,60 @@ func (mr *MockSpaceStorageMockRecorder) StoredIds() *gomock.Call {
}
// TreeDeletedStatus mocks base method.
func (m *MockSpaceStorage) TreeDeletedStatus(arg0 string) (string, error) {
func (m *MockSpaceStorage) TreeDeletedStatus(id string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TreeDeletedStatus", arg0)
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(arg0 any) *gomock.Call {
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), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeDeletedStatus", reflect.TypeOf((*MockSpaceStorage)(nil).TreeDeletedStatus), id)
}
// TreeRoot mocks base method.
func (m *MockSpaceStorage) TreeRoot(arg0 string) (*treechangeproto.RawTreeChangeWithId, error) {
func (m *MockSpaceStorage) TreeRoot(id string) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TreeRoot", arg0)
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(arg0 any) *gomock.Call {
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), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeRoot", reflect.TypeOf((*MockSpaceStorage)(nil).TreeRoot), id)
}
// TreeStorage mocks base method.
func (m *MockSpaceStorage) TreeStorage(arg0 string) (treestorage.TreeStorage, error) {
func (m *MockSpaceStorage) TreeStorage(id string) (treestorage.TreeStorage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TreeStorage", arg0)
ret := m.ctrl.Call(m, "TreeStorage", id)
ret0, _ := ret[0].(treestorage.TreeStorage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// TreeStorage indicates an expected call of TreeStorage.
func (mr *MockSpaceStorageMockRecorder) TreeStorage(arg0 any) *gomock.Call {
func (mr *MockSpaceStorageMockRecorder) TreeStorage(id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).TreeStorage), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).TreeStorage), id)
}
// WriteSpaceHash mocks base method.
func (m *MockSpaceStorage) WriteSpaceHash(arg0 string) error {
func (m *MockSpaceStorage) WriteSpaceHash(hash string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WriteSpaceHash", arg0)
ret := m.ctrl.Call(m, "WriteSpaceHash", hash)
ret0, _ := ret[0].(error)
return ret0
}
// WriteSpaceHash indicates an expected call of WriteSpaceHash.
func (mr *MockSpaceStorageMockRecorder) WriteSpaceHash(arg0 any) *gomock.Call {
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), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteSpaceHash", reflect.TypeOf((*MockSpaceStorage)(nil).WriteSpaceHash), hash)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

65
nodeconf/mock_nodeconf/mock_nodeconf.go
View file

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

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

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