diff --git a/Taskfile.yml b/Taskfile.yml index 4d15ae8..933454b 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -15,6 +15,13 @@ tasks: - go fmt ./... - go mod tidy + gen: + desc: Generate files + sources: + - '**/*.go' + cmds: + - go generate ./... + vet: desc: Vet go code sources: diff --git a/app_test.go b/app_test.go index e850b11..1182eb8 100644 --- a/app_test.go +++ b/app_test.go @@ -4,22 +4,31 @@ import ( "fmt" "testing" - "codeberg.org/danjones000/combluotion/config" - "codeberg.org/danjones000/combluotion/internal/testmocks" vocab "github.com/go-ap/activitypub" "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" + + "codeberg.org/danjones000/combluotion/config" + storeMock "codeberg.org/danjones000/combluotion/internal/testmocks/store" ) +func getStore(t *testing.T) *storeMock.MockStore { + t.Helper() + ctrl := gomock.NewController(t) + return storeMock.NewMockStore(ctrl) +} + func TestEmptyBaseURL(t *testing.T) { c := config.Config{} - a, er := NewApp("0.0.0", c, testmocks.GetStore()) + a, er := NewApp("0.0.0", c, getStore(t)) assert.Nil(t, a) assert.EqualError(t, er, "missing BaseURL") } func TestDefaultEnvironment(t *testing.T) { + store := getStore(t) c := config.Config{BaseURL: "http://localhost:1234/"} - a, er := NewApp("0.0.0", c, testmocks.GetStore()) + a, er := NewApp("0.0.0", c, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, config.Dev, a.Environment()) @@ -40,8 +49,9 @@ func TestGivenEnvironment(t *testing.T) { for _, c := range cases { t.Run(string(c.given), func(t *testing.T) { + store := getStore(t) conf := config.Config{BaseURL: "http://localhost:1234/", Env: c.given} - a, er := NewApp("0.0.0", conf, testmocks.GetStore()) + a, er := NewApp("0.0.0", conf, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, conf, a.Config()) @@ -52,9 +62,10 @@ func TestGivenEnvironment(t *testing.T) { } func TestService(t *testing.T) { + store := getStore(t) base := "http://localhost:1234/" conf := config.Config{BaseURL: base} - a, er := NewApp("0.0.0.0", conf, testmocks.GetStore()) + a, er := NewApp("0.0.0.0", conf, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, vocab.IRI(base), a.ServiceIRI()) @@ -75,9 +86,10 @@ func TestStrings(t *testing.T) { for _, c := range cases { t.Run(c.given, func(t *testing.T) { + store := getStore(t) conf := config.Config{BaseURL: "http://localhost:1234/", Name: c.given} expStr := fmt.Sprintf("%s (%s)", c.exp, "0.0.0.0") - a, er := NewApp("0.0.0.0", conf, testmocks.GetStore()) + a, er := NewApp("0.0.0.0", conf, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, c.exp, a.Name()) diff --git a/go.mod b/go.mod index b5296f3..1b02cbd 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,7 @@ require ( github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f github.com/stretchr/testify v1.9.0 + go.uber.org/mock v0.5.0 ) require ( diff --git a/go.sum b/go.sum index 4a5a48b..b227af7 100644 --- a/go.sum +++ b/go.sum @@ -83,6 +83,8 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ= github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY= +go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= +go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= diff --git a/internal/testmocks/store.go b/internal/testmocks/store.go deleted file mode 100644 index ae408d9..0000000 --- a/internal/testmocks/store.go +++ /dev/null @@ -1,45 +0,0 @@ -package testmocks - -import ( - "codeberg.org/danjones000/combluotion/config" - vocab "github.com/go-ap/activitypub" - "github.com/go-ap/filters" -) - -type st struct{} - -func (s *st) Bootstrap(config.Config) error { - return nil -} - -func (s *st) Load(iri vocab.IRI, filters ...filters.Check) (vocab.Item, error) { - i := vocab.ActorNew(iri, vocab.ActorType) - return i, nil -} - -func (s *st) Save(v vocab.Item) (vocab.Item, error) { - return v, nil -} - -func (s *st) Delete(v vocab.Item) error { - return nil -} - -func (s *st) Create(col vocab.CollectionInterface) (vocab.CollectionInterface, error) { - return col, nil -} - -func (s *st) AddTo(col vocab.IRI, it vocab.Item) error { - return nil -} - -func (s *st) RemoveFrom(col vocab.IRI, it vocab.Item) error { - return nil -} - -func (s *st) Close() { -} - -func GetStore() *st { - return &st{} -} diff --git a/internal/testmocks/store/store_mock.go b/internal/testmocks/store/store_mock.go new file mode 100644 index 0000000..336d745 --- /dev/null +++ b/internal/testmocks/store/store_mock.go @@ -0,0 +1,2260 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: store.go +// +// Generated by this command: +// +// mockgen -source store.go -destination ../internal/testmocks/store/store_mock.go -package store -typed +// + +// Package store is a generated GoMock package. +package store + +import ( + crypto "crypto" + reflect "reflect" + + config "codeberg.org/danjones000/combluotion/config" + activitypub "github.com/go-ap/activitypub" + filters "github.com/go-ap/filters" + processing "github.com/go-ap/processing" + osin "github.com/openshift/osin" + gomock "go.uber.org/mock/gomock" +) + +// MockClientSaver is a mock of ClientSaver interface. +type MockClientSaver struct { + ctrl *gomock.Controller + recorder *MockClientSaverMockRecorder + isgomock struct{} +} + +// MockClientSaverMockRecorder is the mock recorder for MockClientSaver. +type MockClientSaverMockRecorder struct { + mock *MockClientSaver +} + +// NewMockClientSaver creates a new mock instance. +func NewMockClientSaver(ctrl *gomock.Controller) *MockClientSaver { + mock := &MockClientSaver{ctrl: ctrl} + mock.recorder = &MockClientSaverMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClientSaver) EXPECT() *MockClientSaverMockRecorder { + return m.recorder +} + +// CreateClient mocks base method. +func (m *MockClientSaver) CreateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockClientSaverMockRecorder) CreateClient(c any) *MockClientSaverCreateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockClientSaver)(nil).CreateClient), c) + return &MockClientSaverCreateClientCall{Call: call} +} + +// MockClientSaverCreateClientCall wrap *gomock.Call +type MockClientSaverCreateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockClientSaverCreateClientCall) Return(arg0 error) *MockClientSaverCreateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockClientSaverCreateClientCall) Do(f func(osin.Client) error) *MockClientSaverCreateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockClientSaverCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockClientSaverCreateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// RemoveClient mocks base method. +func (m *MockClientSaver) RemoveClient(id string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClient", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveClient indicates an expected call of RemoveClient. +func (mr *MockClientSaverMockRecorder) RemoveClient(id any) *MockClientSaverRemoveClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockClientSaver)(nil).RemoveClient), id) + return &MockClientSaverRemoveClientCall{Call: call} +} + +// MockClientSaverRemoveClientCall wrap *gomock.Call +type MockClientSaverRemoveClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientSaverRemoveClientCall) Return(arg0 error) *MockClientSaverRemoveClientCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientSaverRemoveClientCall) Do(f func(string) error) *MockClientSaverRemoveClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientSaverRemoveClientCall) DoAndReturn(f func(string) error) *MockClientSaverRemoveClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdateClient mocks base method. +func (m *MockClientSaver) UpdateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClient indicates an expected call of UpdateClient. +func (mr *MockClientSaverMockRecorder) UpdateClient(c any) *MockClientSaverUpdateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockClientSaver)(nil).UpdateClient), c) + return &MockClientSaverUpdateClientCall{Call: call} +} + +// MockClientSaverUpdateClientCall wrap *gomock.Call +type MockClientSaverUpdateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockClientSaverUpdateClientCall) Return(arg0 error) *MockClientSaverUpdateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockClientSaverUpdateClientCall) Do(f func(osin.Client) error) *MockClientSaverUpdateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockClientSaverUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockClientSaverUpdateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// MockClientLister is a mock of ClientLister interface. +type MockClientLister struct { + ctrl *gomock.Controller + recorder *MockClientListerMockRecorder + isgomock struct{} +} + +// MockClientListerMockRecorder is the mock recorder for MockClientLister. +type MockClientListerMockRecorder struct { + mock *MockClientLister +} + +// NewMockClientLister creates a new mock instance. +func NewMockClientLister(ctrl *gomock.Controller) *MockClientLister { + mock := &MockClientLister{ctrl: ctrl} + mock.recorder = &MockClientListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClientLister) EXPECT() *MockClientListerMockRecorder { + return m.recorder +} + +// GetClient mocks base method. +func (m *MockClientLister) GetClient(id string) (osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockClientListerMockRecorder) GetClient(id any) *MockClientListerGetClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientLister)(nil).GetClient), id) + return &MockClientListerGetClientCall{Call: call} +} + +// MockClientListerGetClientCall wrap *gomock.Call +type MockClientListerGetClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientListerGetClientCall) Return(arg0 osin.Client, arg1 error) *MockClientListerGetClientCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientListerGetClientCall) Do(f func(string) (osin.Client, error)) *MockClientListerGetClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientListerGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockClientListerGetClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListClients mocks base method. +func (m *MockClientLister) ListClients() ([]osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClients") + ret0, _ := ret[0].([]osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClients indicates an expected call of ListClients. +func (mr *MockClientListerMockRecorder) ListClients() *MockClientListerListClientsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockClientLister)(nil).ListClients)) + return &MockClientListerListClientsCall{Call: call} +} + +// MockClientListerListClientsCall wrap *gomock.Call +type MockClientListerListClientsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientListerListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockClientListerListClientsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientListerListClientsCall) Do(f func() ([]osin.Client, error)) *MockClientListerListClientsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientListerListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockClientListerListClientsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockBootstrapper is a mock of Bootstrapper interface. +type MockBootstrapper struct { + ctrl *gomock.Controller + recorder *MockBootstrapperMockRecorder + isgomock struct{} +} + +// MockBootstrapperMockRecorder is the mock recorder for MockBootstrapper. +type MockBootstrapperMockRecorder struct { + mock *MockBootstrapper +} + +// NewMockBootstrapper creates a new mock instance. +func NewMockBootstrapper(ctrl *gomock.Controller) *MockBootstrapper { + mock := &MockBootstrapper{ctrl: ctrl} + mock.recorder = &MockBootstrapperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBootstrapper) EXPECT() *MockBootstrapperMockRecorder { + return m.recorder +} + +// Bootstrap mocks base method. +func (m *MockBootstrapper) Bootstrap(arg0 config.Config) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bootstrap", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Bootstrap indicates an expected call of Bootstrap. +func (mr *MockBootstrapperMockRecorder) Bootstrap(arg0 any) *MockBootstrapperBootstrapCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockBootstrapper)(nil).Bootstrap), arg0) + return &MockBootstrapperBootstrapCall{Call: call} +} + +// MockBootstrapperBootstrapCall wrap *gomock.Call +type MockBootstrapperBootstrapCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBootstrapperBootstrapCall) Return(arg0 error) *MockBootstrapperBootstrapCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBootstrapperBootstrapCall) Do(f func(config.Config) error) *MockBootstrapperBootstrapCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBootstrapperBootstrapCall) DoAndReturn(f func(config.Config) error) *MockBootstrapperBootstrapCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockStore is a mock of Store interface. +type MockStore struct { + ctrl *gomock.Controller + recorder *MockStoreMockRecorder + isgomock struct{} +} + +// MockStoreMockRecorder is the mock recorder for MockStore. +type MockStoreMockRecorder struct { + mock *MockStore +} + +// NewMockStore creates a new mock instance. +func NewMockStore(ctrl *gomock.Controller) *MockStore { + mock := &MockStore{ctrl: ctrl} + mock.recorder = &MockStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStore) EXPECT() *MockStoreMockRecorder { + return m.recorder +} + +// AddTo mocks base method. +func (m *MockStore) AddTo(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddTo", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddTo indicates an expected call of AddTo. +func (mr *MockStoreMockRecorder) AddTo(col, it any) *MockStoreAddToCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTo", reflect.TypeOf((*MockStore)(nil).AddTo), col, it) + return &MockStoreAddToCall{Call: call} +} + +// MockStoreAddToCall wrap *gomock.Call +type MockStoreAddToCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreAddToCall) Return(arg0 error) *MockStoreAddToCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreAddToCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockStoreAddToCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreAddToCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockStoreAddToCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Bootstrap mocks base method. +func (m *MockStore) Bootstrap(arg0 config.Config) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bootstrap", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Bootstrap indicates an expected call of Bootstrap. +func (mr *MockStoreMockRecorder) Bootstrap(arg0 any) *MockStoreBootstrapCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockStore)(nil).Bootstrap), arg0) + return &MockStoreBootstrapCall{Call: call} +} + +// MockStoreBootstrapCall wrap *gomock.Call +type MockStoreBootstrapCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreBootstrapCall) Return(arg0 error) *MockStoreBootstrapCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreBootstrapCall) Do(f func(config.Config) error) *MockStoreBootstrapCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreBootstrapCall) DoAndReturn(f func(config.Config) error) *MockStoreBootstrapCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Clone mocks base method. +func (m *MockStore) Clone() osin.Storage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Clone") + ret0, _ := ret[0].(osin.Storage) + return ret0 +} + +// Clone indicates an expected call of Clone. +func (mr *MockStoreMockRecorder) Clone() *MockStoreCloneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockStore)(nil).Clone)) + return &MockStoreCloneCall{Call: call} +} + +// MockStoreCloneCall wrap *gomock.Call +type MockStoreCloneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreCloneCall) Return(arg0 osin.Storage) *MockStoreCloneCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreCloneCall) Do(f func() osin.Storage) *MockStoreCloneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreCloneCall) DoAndReturn(f func() osin.Storage) *MockStoreCloneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Close mocks base method. +func (m *MockStore) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockStoreMockRecorder) Close() *MockStoreCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStore)(nil).Close)) + return &MockStoreCloseCall{Call: call} +} + +// MockStoreCloseCall wrap *gomock.Call +type MockStoreCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreCloseCall) Return() *MockStoreCloseCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreCloseCall) Do(f func()) *MockStoreCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreCloseCall) DoAndReturn(f func()) *MockStoreCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Create mocks base method. +func (m *MockStore) Create(col activitypub.CollectionInterface) (activitypub.CollectionInterface, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", col) + ret0, _ := ret[0].(activitypub.CollectionInterface) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockStoreMockRecorder) Create(col any) *MockStoreCreateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStore)(nil).Create), col) + return &MockStoreCreateCall{Call: call} +} + +// MockStoreCreateCall wrap *gomock.Call +type MockStoreCreateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreCreateCall) Return(arg0 activitypub.CollectionInterface, arg1 error) *MockStoreCreateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreCreateCall) Do(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockStoreCreateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreCreateCall) DoAndReturn(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockStoreCreateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreateClient mocks base method. +func (m *MockStore) CreateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockStoreMockRecorder) CreateClient(c any) *MockStoreCreateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockStore)(nil).CreateClient), c) + return &MockStoreCreateClientCall{Call: call} +} + +// MockStoreCreateClientCall wrap *gomock.Call +type MockStoreCreateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockStoreCreateClientCall) Return(arg0 error) *MockStoreCreateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockStoreCreateClientCall) Do(f func(osin.Client) error) *MockStoreCreateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockStoreCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockStoreCreateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// Delete mocks base method. +func (m *MockStore) Delete(arg0 activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockStoreMockRecorder) Delete(arg0 any) *MockStoreDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStore)(nil).Delete), arg0) + return &MockStoreDeleteCall{Call: call} +} + +// MockStoreDeleteCall wrap *gomock.Call +type MockStoreDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreDeleteCall) Return(arg0 error) *MockStoreDeleteCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreDeleteCall) Do(f func(activitypub.Item) error) *MockStoreDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreDeleteCall) DoAndReturn(f func(activitypub.Item) error) *MockStoreDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetClient mocks base method. +func (m *MockStore) GetClient(id string) (osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockStoreMockRecorder) GetClient(id any) *MockStoreGetClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockStore)(nil).GetClient), id) + return &MockStoreGetClientCall{Call: call} +} + +// MockStoreGetClientCall wrap *gomock.Call +type MockStoreGetClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreGetClientCall) Return(arg0 osin.Client, arg1 error) *MockStoreGetClientCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreGetClientCall) Do(f func(string) (osin.Client, error)) *MockStoreGetClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockStoreGetClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListClients mocks base method. +func (m *MockStore) ListClients() ([]osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClients") + ret0, _ := ret[0].([]osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClients indicates an expected call of ListClients. +func (mr *MockStoreMockRecorder) ListClients() *MockStoreListClientsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockStore)(nil).ListClients)) + return &MockStoreListClientsCall{Call: call} +} + +// MockStoreListClientsCall wrap *gomock.Call +type MockStoreListClientsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockStoreListClientsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreListClientsCall) Do(f func() ([]osin.Client, error)) *MockStoreListClientsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockStoreListClientsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Load mocks base method. +func (m *MockStore) Load(arg0 activitypub.IRI, arg1 ...filters.Check) (activitypub.Item, error) { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Load", varargs...) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Load indicates an expected call of Load. +func (mr *MockStoreMockRecorder) Load(arg0 any, arg1 ...any) *MockStoreLoadCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockStore)(nil).Load), varargs...) + return &MockStoreLoadCall{Call: call} +} + +// MockStoreLoadCall wrap *gomock.Call +type MockStoreLoadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadCall) Return(arg0 activitypub.Item, arg1 error) *MockStoreLoadCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadCall) Do(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockStoreLoadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadCall) DoAndReturn(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockStoreLoadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAccess mocks base method. +func (m *MockStore) LoadAccess(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAccess", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAccess indicates an expected call of LoadAccess. +func (mr *MockStoreMockRecorder) LoadAccess(token any) *MockStoreLoadAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAccess", reflect.TypeOf((*MockStore)(nil).LoadAccess), token) + return &MockStoreLoadAccessCall{Call: call} +} + +// MockStoreLoadAccessCall wrap *gomock.Call +type MockStoreLoadAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadAccessCall) Return(arg0 *osin.AccessData, arg1 error) *MockStoreLoadAccessCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadAccessCall) Do(f func(string) (*osin.AccessData, error)) *MockStoreLoadAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadAccessCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockStoreLoadAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAuthorize mocks base method. +func (m *MockStore) LoadAuthorize(code string) (*osin.AuthorizeData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAuthorize", code) + ret0, _ := ret[0].(*osin.AuthorizeData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAuthorize indicates an expected call of LoadAuthorize. +func (mr *MockStoreMockRecorder) LoadAuthorize(code any) *MockStoreLoadAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAuthorize", reflect.TypeOf((*MockStore)(nil).LoadAuthorize), code) + return &MockStoreLoadAuthorizeCall{Call: call} +} + +// MockStoreLoadAuthorizeCall wrap *gomock.Call +type MockStoreLoadAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadAuthorizeCall) Return(arg0 *osin.AuthorizeData, arg1 error) *MockStoreLoadAuthorizeCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadAuthorizeCall) Do(f func(string) (*osin.AuthorizeData, error)) *MockStoreLoadAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadAuthorizeCall) DoAndReturn(f func(string) (*osin.AuthorizeData, error)) *MockStoreLoadAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadKey mocks base method. +func (m *MockStore) LoadKey(arg0 activitypub.IRI) (crypto.PrivateKey, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadKey", arg0) + ret0, _ := ret[0].(crypto.PrivateKey) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadKey indicates an expected call of LoadKey. +func (mr *MockStoreMockRecorder) LoadKey(arg0 any) *MockStoreLoadKeyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKey", reflect.TypeOf((*MockStore)(nil).LoadKey), arg0) + return &MockStoreLoadKeyCall{Call: call} +} + +// MockStoreLoadKeyCall wrap *gomock.Call +type MockStoreLoadKeyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadKeyCall) Return(arg0 crypto.PrivateKey, arg1 error) *MockStoreLoadKeyCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadKeyCall) Do(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockStoreLoadKeyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadKeyCall) DoAndReturn(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockStoreLoadKeyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadMetadata mocks base method. +func (m *MockStore) LoadMetadata(arg0 activitypub.IRI) (*processing.Metadata, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadMetadata", arg0) + ret0, _ := ret[0].(*processing.Metadata) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadMetadata indicates an expected call of LoadMetadata. +func (mr *MockStoreMockRecorder) LoadMetadata(arg0 any) *MockStoreLoadMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockStore)(nil).LoadMetadata), arg0) + return &MockStoreLoadMetadataCall{Call: call} +} + +// MockStoreLoadMetadataCall wrap *gomock.Call +type MockStoreLoadMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadMetadataCall) Return(arg0 *processing.Metadata, arg1 error) *MockStoreLoadMetadataCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadMetadataCall) Do(f func(activitypub.IRI) (*processing.Metadata, error)) *MockStoreLoadMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadMetadataCall) DoAndReturn(f func(activitypub.IRI) (*processing.Metadata, error)) *MockStoreLoadMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadRefresh mocks base method. +func (m *MockStore) LoadRefresh(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadRefresh", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadRefresh indicates an expected call of LoadRefresh. +func (mr *MockStoreMockRecorder) LoadRefresh(token any) *MockStoreLoadRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRefresh", reflect.TypeOf((*MockStore)(nil).LoadRefresh), token) + return &MockStoreLoadRefreshCall{Call: call} +} + +// MockStoreLoadRefreshCall wrap *gomock.Call +type MockStoreLoadRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadRefreshCall) Return(arg0 *osin.AccessData, arg1 error) *MockStoreLoadRefreshCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadRefreshCall) Do(f func(string) (*osin.AccessData, error)) *MockStoreLoadRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadRefreshCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockStoreLoadRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAccess mocks base method. +func (m *MockStore) RemoveAccess(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAccess", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAccess indicates an expected call of RemoveAccess. +func (mr *MockStoreMockRecorder) RemoveAccess(token any) *MockStoreRemoveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccess", reflect.TypeOf((*MockStore)(nil).RemoveAccess), token) + return &MockStoreRemoveAccessCall{Call: call} +} + +// MockStoreRemoveAccessCall wrap *gomock.Call +type MockStoreRemoveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveAccessCall) Return(arg0 error) *MockStoreRemoveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveAccessCall) Do(f func(string) error) *MockStoreRemoveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveAccessCall) DoAndReturn(f func(string) error) *MockStoreRemoveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAuthorize mocks base method. +func (m *MockStore) RemoveAuthorize(code string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAuthorize", code) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAuthorize indicates an expected call of RemoveAuthorize. +func (mr *MockStoreMockRecorder) RemoveAuthorize(code any) *MockStoreRemoveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAuthorize", reflect.TypeOf((*MockStore)(nil).RemoveAuthorize), code) + return &MockStoreRemoveAuthorizeCall{Call: call} +} + +// MockStoreRemoveAuthorizeCall wrap *gomock.Call +type MockStoreRemoveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveAuthorizeCall) Return(arg0 error) *MockStoreRemoveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveAuthorizeCall) Do(f func(string) error) *MockStoreRemoveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveAuthorizeCall) DoAndReturn(f func(string) error) *MockStoreRemoveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveClient mocks base method. +func (m *MockStore) RemoveClient(id string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClient", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveClient indicates an expected call of RemoveClient. +func (mr *MockStoreMockRecorder) RemoveClient(id any) *MockStoreRemoveClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockStore)(nil).RemoveClient), id) + return &MockStoreRemoveClientCall{Call: call} +} + +// MockStoreRemoveClientCall wrap *gomock.Call +type MockStoreRemoveClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveClientCall) Return(arg0 error) *MockStoreRemoveClientCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveClientCall) Do(f func(string) error) *MockStoreRemoveClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveClientCall) DoAndReturn(f func(string) error) *MockStoreRemoveClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveFrom mocks base method. +func (m *MockStore) RemoveFrom(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveFrom", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveFrom indicates an expected call of RemoveFrom. +func (mr *MockStoreMockRecorder) RemoveFrom(col, it any) *MockStoreRemoveFromCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFrom", reflect.TypeOf((*MockStore)(nil).RemoveFrom), col, it) + return &MockStoreRemoveFromCall{Call: call} +} + +// MockStoreRemoveFromCall wrap *gomock.Call +type MockStoreRemoveFromCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveFromCall) Return(arg0 error) *MockStoreRemoveFromCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveFromCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockStoreRemoveFromCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveFromCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockStoreRemoveFromCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveRefresh mocks base method. +func (m *MockStore) RemoveRefresh(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveRefresh", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveRefresh indicates an expected call of RemoveRefresh. +func (mr *MockStoreMockRecorder) RemoveRefresh(token any) *MockStoreRemoveRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRefresh", reflect.TypeOf((*MockStore)(nil).RemoveRefresh), token) + return &MockStoreRemoveRefreshCall{Call: call} +} + +// MockStoreRemoveRefreshCall wrap *gomock.Call +type MockStoreRemoveRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveRefreshCall) Return(arg0 error) *MockStoreRemoveRefreshCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveRefreshCall) Do(f func(string) error) *MockStoreRemoveRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveRefreshCall) DoAndReturn(f func(string) error) *MockStoreRemoveRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Save mocks base method. +func (m *MockStore) Save(arg0 activitypub.Item) (activitypub.Item, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", arg0) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Save indicates an expected call of Save. +func (mr *MockStoreMockRecorder) Save(arg0 any) *MockStoreSaveCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStore)(nil).Save), arg0) + return &MockStoreSaveCall{Call: call} +} + +// MockStoreSaveCall wrap *gomock.Call +type MockStoreSaveCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveCall) Return(arg0 activitypub.Item, arg1 error) *MockStoreSaveCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveCall) Do(f func(activitypub.Item) (activitypub.Item, error)) *MockStoreSaveCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveCall) DoAndReturn(f func(activitypub.Item) (activitypub.Item, error)) *MockStoreSaveCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAccess mocks base method. +func (m *MockStore) SaveAccess(arg0 *osin.AccessData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAccess", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAccess indicates an expected call of SaveAccess. +func (mr *MockStoreMockRecorder) SaveAccess(arg0 any) *MockStoreSaveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAccess", reflect.TypeOf((*MockStore)(nil).SaveAccess), arg0) + return &MockStoreSaveAccessCall{Call: call} +} + +// MockStoreSaveAccessCall wrap *gomock.Call +type MockStoreSaveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveAccessCall) Return(arg0 error) *MockStoreSaveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveAccessCall) Do(f func(*osin.AccessData) error) *MockStoreSaveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveAccessCall) DoAndReturn(f func(*osin.AccessData) error) *MockStoreSaveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAuthorize mocks base method. +func (m *MockStore) SaveAuthorize(arg0 *osin.AuthorizeData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAuthorize", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAuthorize indicates an expected call of SaveAuthorize. +func (mr *MockStoreMockRecorder) SaveAuthorize(arg0 any) *MockStoreSaveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorize", reflect.TypeOf((*MockStore)(nil).SaveAuthorize), arg0) + return &MockStoreSaveAuthorizeCall{Call: call} +} + +// MockStoreSaveAuthorizeCall wrap *gomock.Call +type MockStoreSaveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveAuthorizeCall) Return(arg0 error) *MockStoreSaveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveAuthorizeCall) Do(f func(*osin.AuthorizeData) error) *MockStoreSaveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveAuthorizeCall) DoAndReturn(f func(*osin.AuthorizeData) error) *MockStoreSaveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveMetadata mocks base method. +func (m *MockStore) SaveMetadata(arg0 processing.Metadata, arg1 activitypub.IRI) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveMetadata", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveMetadata indicates an expected call of SaveMetadata. +func (mr *MockStoreMockRecorder) SaveMetadata(arg0, arg1 any) *MockStoreSaveMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetadata", reflect.TypeOf((*MockStore)(nil).SaveMetadata), arg0, arg1) + return &MockStoreSaveMetadataCall{Call: call} +} + +// MockStoreSaveMetadataCall wrap *gomock.Call +type MockStoreSaveMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveMetadataCall) Return(arg0 error) *MockStoreSaveMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveMetadataCall) Do(f func(processing.Metadata, activitypub.IRI) error) *MockStoreSaveMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveMetadataCall) DoAndReturn(f func(processing.Metadata, activitypub.IRI) error) *MockStoreSaveMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdateClient mocks base method. +func (m *MockStore) UpdateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClient indicates an expected call of UpdateClient. +func (mr *MockStoreMockRecorder) UpdateClient(c any) *MockStoreUpdateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockStore)(nil).UpdateClient), c) + return &MockStoreUpdateClientCall{Call: call} +} + +// MockStoreUpdateClientCall wrap *gomock.Call +type MockStoreUpdateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockStoreUpdateClientCall) Return(arg0 error) *MockStoreUpdateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockStoreUpdateClientCall) Do(f func(osin.Client) error) *MockStoreUpdateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockStoreUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockStoreUpdateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// MockPartStore is a mock of PartStore interface. +type MockPartStore struct { + ctrl *gomock.Controller + recorder *MockPartStoreMockRecorder + isgomock struct{} +} + +// MockPartStoreMockRecorder is the mock recorder for MockPartStore. +type MockPartStoreMockRecorder struct { + mock *MockPartStore +} + +// NewMockPartStore creates a new mock instance. +func NewMockPartStore(ctrl *gomock.Controller) *MockPartStore { + mock := &MockPartStore{ctrl: ctrl} + mock.recorder = &MockPartStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPartStore) EXPECT() *MockPartStoreMockRecorder { + return m.recorder +} + +// AddTo mocks base method. +func (m *MockPartStore) AddTo(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddTo", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddTo indicates an expected call of AddTo. +func (mr *MockPartStoreMockRecorder) AddTo(col, it any) *MockPartStoreAddToCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTo", reflect.TypeOf((*MockPartStore)(nil).AddTo), col, it) + return &MockPartStoreAddToCall{Call: call} +} + +// MockPartStoreAddToCall wrap *gomock.Call +type MockPartStoreAddToCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreAddToCall) Return(arg0 error) *MockPartStoreAddToCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreAddToCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreAddToCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreAddToCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreAddToCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Clone mocks base method. +func (m *MockPartStore) Clone() osin.Storage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Clone") + ret0, _ := ret[0].(osin.Storage) + return ret0 +} + +// Clone indicates an expected call of Clone. +func (mr *MockPartStoreMockRecorder) Clone() *MockPartStoreCloneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockPartStore)(nil).Clone)) + return &MockPartStoreCloneCall{Call: call} +} + +// MockPartStoreCloneCall wrap *gomock.Call +type MockPartStoreCloneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreCloneCall) Return(arg0 osin.Storage) *MockPartStoreCloneCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreCloneCall) Do(f func() osin.Storage) *MockPartStoreCloneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreCloneCall) DoAndReturn(f func() osin.Storage) *MockPartStoreCloneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Close mocks base method. +func (m *MockPartStore) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockPartStoreMockRecorder) Close() *MockPartStoreCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPartStore)(nil).Close)) + return &MockPartStoreCloseCall{Call: call} +} + +// MockPartStoreCloseCall wrap *gomock.Call +type MockPartStoreCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreCloseCall) Return() *MockPartStoreCloseCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreCloseCall) Do(f func()) *MockPartStoreCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreCloseCall) DoAndReturn(f func()) *MockPartStoreCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Create mocks base method. +func (m *MockPartStore) Create(col activitypub.CollectionInterface) (activitypub.CollectionInterface, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", col) + ret0, _ := ret[0].(activitypub.CollectionInterface) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockPartStoreMockRecorder) Create(col any) *MockPartStoreCreateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPartStore)(nil).Create), col) + return &MockPartStoreCreateCall{Call: call} +} + +// MockPartStoreCreateCall wrap *gomock.Call +type MockPartStoreCreateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreCreateCall) Return(arg0 activitypub.CollectionInterface, arg1 error) *MockPartStoreCreateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreCreateCall) Do(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockPartStoreCreateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreCreateCall) DoAndReturn(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockPartStoreCreateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreateClient mocks base method. +func (m *MockPartStore) CreateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockPartStoreMockRecorder) CreateClient(c any) *MockPartStoreCreateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockPartStore)(nil).CreateClient), c) + return &MockPartStoreCreateClientCall{Call: call} +} + +// MockPartStoreCreateClientCall wrap *gomock.Call +type MockPartStoreCreateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockPartStoreCreateClientCall) Return(arg0 error) *MockPartStoreCreateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockPartStoreCreateClientCall) Do(f func(osin.Client) error) *MockPartStoreCreateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockPartStoreCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockPartStoreCreateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// Delete mocks base method. +func (m *MockPartStore) Delete(arg0 activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockPartStoreMockRecorder) Delete(arg0 any) *MockPartStoreDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPartStore)(nil).Delete), arg0) + return &MockPartStoreDeleteCall{Call: call} +} + +// MockPartStoreDeleteCall wrap *gomock.Call +type MockPartStoreDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreDeleteCall) Return(arg0 error) *MockPartStoreDeleteCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreDeleteCall) Do(f func(activitypub.Item) error) *MockPartStoreDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreDeleteCall) DoAndReturn(f func(activitypub.Item) error) *MockPartStoreDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetClient mocks base method. +func (m *MockPartStore) GetClient(id string) (osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockPartStoreMockRecorder) GetClient(id any) *MockPartStoreGetClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockPartStore)(nil).GetClient), id) + return &MockPartStoreGetClientCall{Call: call} +} + +// MockPartStoreGetClientCall wrap *gomock.Call +type MockPartStoreGetClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreGetClientCall) Return(arg0 osin.Client, arg1 error) *MockPartStoreGetClientCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreGetClientCall) Do(f func(string) (osin.Client, error)) *MockPartStoreGetClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockPartStoreGetClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListClients mocks base method. +func (m *MockPartStore) ListClients() ([]osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClients") + ret0, _ := ret[0].([]osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClients indicates an expected call of ListClients. +func (mr *MockPartStoreMockRecorder) ListClients() *MockPartStoreListClientsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockPartStore)(nil).ListClients)) + return &MockPartStoreListClientsCall{Call: call} +} + +// MockPartStoreListClientsCall wrap *gomock.Call +type MockPartStoreListClientsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockPartStoreListClientsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreListClientsCall) Do(f func() ([]osin.Client, error)) *MockPartStoreListClientsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockPartStoreListClientsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Load mocks base method. +func (m *MockPartStore) Load(arg0 activitypub.IRI, arg1 ...filters.Check) (activitypub.Item, error) { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Load", varargs...) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Load indicates an expected call of Load. +func (mr *MockPartStoreMockRecorder) Load(arg0 any, arg1 ...any) *MockPartStoreLoadCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockPartStore)(nil).Load), varargs...) + return &MockPartStoreLoadCall{Call: call} +} + +// MockPartStoreLoadCall wrap *gomock.Call +type MockPartStoreLoadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadCall) Return(arg0 activitypub.Item, arg1 error) *MockPartStoreLoadCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadCall) Do(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockPartStoreLoadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadCall) DoAndReturn(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockPartStoreLoadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAccess mocks base method. +func (m *MockPartStore) LoadAccess(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAccess", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAccess indicates an expected call of LoadAccess. +func (mr *MockPartStoreMockRecorder) LoadAccess(token any) *MockPartStoreLoadAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAccess", reflect.TypeOf((*MockPartStore)(nil).LoadAccess), token) + return &MockPartStoreLoadAccessCall{Call: call} +} + +// MockPartStoreLoadAccessCall wrap *gomock.Call +type MockPartStoreLoadAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadAccessCall) Return(arg0 *osin.AccessData, arg1 error) *MockPartStoreLoadAccessCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadAccessCall) Do(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadAccessCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAuthorize mocks base method. +func (m *MockPartStore) LoadAuthorize(code string) (*osin.AuthorizeData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAuthorize", code) + ret0, _ := ret[0].(*osin.AuthorizeData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAuthorize indicates an expected call of LoadAuthorize. +func (mr *MockPartStoreMockRecorder) LoadAuthorize(code any) *MockPartStoreLoadAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAuthorize", reflect.TypeOf((*MockPartStore)(nil).LoadAuthorize), code) + return &MockPartStoreLoadAuthorizeCall{Call: call} +} + +// MockPartStoreLoadAuthorizeCall wrap *gomock.Call +type MockPartStoreLoadAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadAuthorizeCall) Return(arg0 *osin.AuthorizeData, arg1 error) *MockPartStoreLoadAuthorizeCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadAuthorizeCall) Do(f func(string) (*osin.AuthorizeData, error)) *MockPartStoreLoadAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadAuthorizeCall) DoAndReturn(f func(string) (*osin.AuthorizeData, error)) *MockPartStoreLoadAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadKey mocks base method. +func (m *MockPartStore) LoadKey(arg0 activitypub.IRI) (crypto.PrivateKey, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadKey", arg0) + ret0, _ := ret[0].(crypto.PrivateKey) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadKey indicates an expected call of LoadKey. +func (mr *MockPartStoreMockRecorder) LoadKey(arg0 any) *MockPartStoreLoadKeyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKey", reflect.TypeOf((*MockPartStore)(nil).LoadKey), arg0) + return &MockPartStoreLoadKeyCall{Call: call} +} + +// MockPartStoreLoadKeyCall wrap *gomock.Call +type MockPartStoreLoadKeyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadKeyCall) Return(arg0 crypto.PrivateKey, arg1 error) *MockPartStoreLoadKeyCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadKeyCall) Do(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockPartStoreLoadKeyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadKeyCall) DoAndReturn(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockPartStoreLoadKeyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadMetadata mocks base method. +func (m *MockPartStore) LoadMetadata(arg0 activitypub.IRI) (*processing.Metadata, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadMetadata", arg0) + ret0, _ := ret[0].(*processing.Metadata) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadMetadata indicates an expected call of LoadMetadata. +func (mr *MockPartStoreMockRecorder) LoadMetadata(arg0 any) *MockPartStoreLoadMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockPartStore)(nil).LoadMetadata), arg0) + return &MockPartStoreLoadMetadataCall{Call: call} +} + +// MockPartStoreLoadMetadataCall wrap *gomock.Call +type MockPartStoreLoadMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadMetadataCall) Return(arg0 *processing.Metadata, arg1 error) *MockPartStoreLoadMetadataCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadMetadataCall) Do(f func(activitypub.IRI) (*processing.Metadata, error)) *MockPartStoreLoadMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadMetadataCall) DoAndReturn(f func(activitypub.IRI) (*processing.Metadata, error)) *MockPartStoreLoadMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadRefresh mocks base method. +func (m *MockPartStore) LoadRefresh(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadRefresh", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadRefresh indicates an expected call of LoadRefresh. +func (mr *MockPartStoreMockRecorder) LoadRefresh(token any) *MockPartStoreLoadRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRefresh", reflect.TypeOf((*MockPartStore)(nil).LoadRefresh), token) + return &MockPartStoreLoadRefreshCall{Call: call} +} + +// MockPartStoreLoadRefreshCall wrap *gomock.Call +type MockPartStoreLoadRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadRefreshCall) Return(arg0 *osin.AccessData, arg1 error) *MockPartStoreLoadRefreshCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadRefreshCall) Do(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadRefreshCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAccess mocks base method. +func (m *MockPartStore) RemoveAccess(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAccess", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAccess indicates an expected call of RemoveAccess. +func (mr *MockPartStoreMockRecorder) RemoveAccess(token any) *MockPartStoreRemoveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccess", reflect.TypeOf((*MockPartStore)(nil).RemoveAccess), token) + return &MockPartStoreRemoveAccessCall{Call: call} +} + +// MockPartStoreRemoveAccessCall wrap *gomock.Call +type MockPartStoreRemoveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveAccessCall) Return(arg0 error) *MockPartStoreRemoveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveAccessCall) Do(f func(string) error) *MockPartStoreRemoveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveAccessCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAuthorize mocks base method. +func (m *MockPartStore) RemoveAuthorize(code string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAuthorize", code) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAuthorize indicates an expected call of RemoveAuthorize. +func (mr *MockPartStoreMockRecorder) RemoveAuthorize(code any) *MockPartStoreRemoveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAuthorize", reflect.TypeOf((*MockPartStore)(nil).RemoveAuthorize), code) + return &MockPartStoreRemoveAuthorizeCall{Call: call} +} + +// MockPartStoreRemoveAuthorizeCall wrap *gomock.Call +type MockPartStoreRemoveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveAuthorizeCall) Return(arg0 error) *MockPartStoreRemoveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveAuthorizeCall) Do(f func(string) error) *MockPartStoreRemoveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveAuthorizeCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveClient mocks base method. +func (m *MockPartStore) RemoveClient(id string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClient", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveClient indicates an expected call of RemoveClient. +func (mr *MockPartStoreMockRecorder) RemoveClient(id any) *MockPartStoreRemoveClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockPartStore)(nil).RemoveClient), id) + return &MockPartStoreRemoveClientCall{Call: call} +} + +// MockPartStoreRemoveClientCall wrap *gomock.Call +type MockPartStoreRemoveClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveClientCall) Return(arg0 error) *MockPartStoreRemoveClientCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveClientCall) Do(f func(string) error) *MockPartStoreRemoveClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveClientCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveFrom mocks base method. +func (m *MockPartStore) RemoveFrom(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveFrom", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveFrom indicates an expected call of RemoveFrom. +func (mr *MockPartStoreMockRecorder) RemoveFrom(col, it any) *MockPartStoreRemoveFromCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFrom", reflect.TypeOf((*MockPartStore)(nil).RemoveFrom), col, it) + return &MockPartStoreRemoveFromCall{Call: call} +} + +// MockPartStoreRemoveFromCall wrap *gomock.Call +type MockPartStoreRemoveFromCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveFromCall) Return(arg0 error) *MockPartStoreRemoveFromCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveFromCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreRemoveFromCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveFromCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreRemoveFromCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveRefresh mocks base method. +func (m *MockPartStore) RemoveRefresh(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveRefresh", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveRefresh indicates an expected call of RemoveRefresh. +func (mr *MockPartStoreMockRecorder) RemoveRefresh(token any) *MockPartStoreRemoveRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRefresh", reflect.TypeOf((*MockPartStore)(nil).RemoveRefresh), token) + return &MockPartStoreRemoveRefreshCall{Call: call} +} + +// MockPartStoreRemoveRefreshCall wrap *gomock.Call +type MockPartStoreRemoveRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveRefreshCall) Return(arg0 error) *MockPartStoreRemoveRefreshCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveRefreshCall) Do(f func(string) error) *MockPartStoreRemoveRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveRefreshCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Save mocks base method. +func (m *MockPartStore) Save(arg0 activitypub.Item) (activitypub.Item, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", arg0) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Save indicates an expected call of Save. +func (mr *MockPartStoreMockRecorder) Save(arg0 any) *MockPartStoreSaveCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockPartStore)(nil).Save), arg0) + return &MockPartStoreSaveCall{Call: call} +} + +// MockPartStoreSaveCall wrap *gomock.Call +type MockPartStoreSaveCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveCall) Return(arg0 activitypub.Item, arg1 error) *MockPartStoreSaveCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveCall) Do(f func(activitypub.Item) (activitypub.Item, error)) *MockPartStoreSaveCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveCall) DoAndReturn(f func(activitypub.Item) (activitypub.Item, error)) *MockPartStoreSaveCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAccess mocks base method. +func (m *MockPartStore) SaveAccess(arg0 *osin.AccessData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAccess", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAccess indicates an expected call of SaveAccess. +func (mr *MockPartStoreMockRecorder) SaveAccess(arg0 any) *MockPartStoreSaveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAccess", reflect.TypeOf((*MockPartStore)(nil).SaveAccess), arg0) + return &MockPartStoreSaveAccessCall{Call: call} +} + +// MockPartStoreSaveAccessCall wrap *gomock.Call +type MockPartStoreSaveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveAccessCall) Return(arg0 error) *MockPartStoreSaveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveAccessCall) Do(f func(*osin.AccessData) error) *MockPartStoreSaveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveAccessCall) DoAndReturn(f func(*osin.AccessData) error) *MockPartStoreSaveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAuthorize mocks base method. +func (m *MockPartStore) SaveAuthorize(arg0 *osin.AuthorizeData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAuthorize", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAuthorize indicates an expected call of SaveAuthorize. +func (mr *MockPartStoreMockRecorder) SaveAuthorize(arg0 any) *MockPartStoreSaveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorize", reflect.TypeOf((*MockPartStore)(nil).SaveAuthorize), arg0) + return &MockPartStoreSaveAuthorizeCall{Call: call} +} + +// MockPartStoreSaveAuthorizeCall wrap *gomock.Call +type MockPartStoreSaveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveAuthorizeCall) Return(arg0 error) *MockPartStoreSaveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveAuthorizeCall) Do(f func(*osin.AuthorizeData) error) *MockPartStoreSaveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveAuthorizeCall) DoAndReturn(f func(*osin.AuthorizeData) error) *MockPartStoreSaveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveMetadata mocks base method. +func (m *MockPartStore) SaveMetadata(arg0 processing.Metadata, arg1 activitypub.IRI) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveMetadata", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveMetadata indicates an expected call of SaveMetadata. +func (mr *MockPartStoreMockRecorder) SaveMetadata(arg0, arg1 any) *MockPartStoreSaveMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetadata", reflect.TypeOf((*MockPartStore)(nil).SaveMetadata), arg0, arg1) + return &MockPartStoreSaveMetadataCall{Call: call} +} + +// MockPartStoreSaveMetadataCall wrap *gomock.Call +type MockPartStoreSaveMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveMetadataCall) Return(arg0 error) *MockPartStoreSaveMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveMetadataCall) Do(f func(processing.Metadata, activitypub.IRI) error) *MockPartStoreSaveMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveMetadataCall) DoAndReturn(f func(processing.Metadata, activitypub.IRI) error) *MockPartStoreSaveMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdateClient mocks base method. +func (m *MockPartStore) UpdateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClient indicates an expected call of UpdateClient. +func (mr *MockPartStoreMockRecorder) UpdateClient(c any) *MockPartStoreUpdateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockPartStore)(nil).UpdateClient), c) + return &MockPartStoreUpdateClientCall{Call: call} +} + +// MockPartStoreUpdateClientCall wrap *gomock.Call +type MockPartStoreUpdateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockPartStoreUpdateClientCall) Return(arg0 error) *MockPartStoreUpdateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockPartStoreUpdateClientCall) Do(f func(osin.Client) error) *MockPartStoreUpdateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockPartStoreUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockPartStoreUpdateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} diff --git a/internal/testmocks/store_meta.go b/internal/testmocks/store_meta.go deleted file mode 100644 index 316ace0..0000000 --- a/internal/testmocks/store_meta.go +++ /dev/null @@ -1,20 +0,0 @@ -package testmocks - -import ( - "crypto" - - vocab "github.com/go-ap/activitypub" - proc "github.com/go-ap/processing" -) - -func (s *st) LoadKey(vocab.IRI) (crypto.PrivateKey, error) { - return nil, nil -} - -func (s *st) LoadMetadata(vocab.IRI) (*proc.Metadata, error) { - return nil, nil -} - -func (s *st) SaveMetadata(proc.Metadata, vocab.IRI) error { - return nil -} diff --git a/internal/testmocks/store_osin_auth.go b/internal/testmocks/store_osin_auth.go deleted file mode 100644 index a266cb1..0000000 --- a/internal/testmocks/store_osin_auth.go +++ /dev/null @@ -1,37 +0,0 @@ -package testmocks - -import ( - "github.com/openshift/osin" -) - -func (s *st) LoadAccess(string) (*osin.AccessData, error) { - return nil, nil -} - -func (s *st) SaveAccess(*osin.AccessData) error { - return nil -} - -func (s *st) RemoveAccess(string) error { - return nil -} - -func (s *st) LoadAuthorize(string) (*osin.AuthorizeData, error) { - return nil, nil -} - -func (s *st) SaveAuthorize(*osin.AuthorizeData) error { - return nil -} - -func (s *st) RemoveAuthorize(string) error { - return nil -} - -func (s *st) LoadRefresh(string) (*osin.AccessData, error) { - return nil, nil -} - -func (s *st) RemoveRefresh(string) error { - return nil -} diff --git a/internal/testmocks/store_osin_client.go b/internal/testmocks/store_osin_client.go deleted file mode 100644 index 980379d..0000000 --- a/internal/testmocks/store_osin_client.go +++ /dev/null @@ -1,30 +0,0 @@ -package testmocks - -import ( - "github.com/openshift/osin" -) - -func (s *st) Clone() osin.Storage { - n := *s - return &n -} - -func (s *st) GetClient(string) (osin.Client, error) { - return &osin.DefaultClient{}, nil -} - -func (s *st) CreateClient(osin.Client) error { - return nil -} - -func (s *st) UpdateClient(osin.Client) error { - return nil -} - -func (s *st) RemoveClient(string) error { - return nil -} - -func (s *st) ListClients() (cl []osin.Client, er error) { - return -} diff --git a/store/factory_test.go b/store/factory_test.go index 5af7acf..f4aa205 100644 --- a/store/factory_test.go +++ b/store/factory_test.go @@ -3,16 +3,23 @@ package store import ( "testing" - "codeberg.org/danjones000/combluotion/config" - "codeberg.org/danjones000/combluotion/internal/testmocks" "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" + + "codeberg.org/danjones000/combluotion/config" + storeMock "codeberg.org/danjones000/combluotion/internal/testmocks/store" ) -var f StoreFactory = func(config.Config) (Store, error) { - return testmocks.GetStore(), nil +func getStoreFactory(t *testing.T) (*gomock.Controller, StoreFactory) { + t.Helper() + ctrl := gomock.NewController(t) + return ctrl, func(config.Config) (Store, error) { + return storeMock.NewMockStore(ctrl), nil + } } func TestAddFactory(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") _, ok := factories["mock"] @@ -25,9 +32,10 @@ func TestGetFactoryNil(t *testing.T) { } func TestGetFactoryNotNil(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") - f := GetFactory("mock") + f = GetFactory("mock") assert.NotNil(t, f) } @@ -39,6 +47,7 @@ func TestMakeStoreError(t *testing.T) { } func TestMakeStoreNoError(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") s, e := MakeStore("mock", config.Config{}) @@ -47,6 +56,7 @@ func TestMakeStoreNoError(t *testing.T) { } func TestMakeStoreNoName(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") s, e := MakeStore("", config.Config{ diff --git a/store/store.go b/store/store.go index e66fa9b..e4868d8 100644 --- a/store/store.go +++ b/store/store.go @@ -7,6 +7,8 @@ import ( "github.com/openshift/osin" ) +//go:generate mockgen -source store.go -destination ../internal/testmocks/store/store_mock.go -package store -typed + type ClientSaver interface { // UpdateClient updates the client (identified by it's id) and replaces the values with the values of client. UpdateClient(c osin.Client) error