storage_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: storage.go

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	reflect "reflect"

	model "github.com/andatoshiki/toshiki-rssbot/internal/model"
	storage "github.com/andatoshiki/toshiki-rssbot/internal/storage"
	gomock "github.com/golang/mock/gomock"
)

// MockStorage is a mock of Storage interface.
type MockStorage struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMockRecorder
}

// MockStorageMockRecorder is the mock recorder for MockStorage.
type MockStorageMockRecorder struct {
	mock *MockStorage
}

// NewMockStorage creates a new mock instance.
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
	mock := &MockStorage{ctrl: ctrl}
	mock.recorder = &MockStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStorage) EXPECT() *MockStorageMockRecorder {
	return m.recorder
}

// Init mocks base method.
func (m *MockStorage) Init(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockStorageMockRecorder) Init(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockStorage)(nil).Init), ctx)
}

// MockUser is a mock of User interface.
type MockUser struct {
	ctrl     *gomock.Controller
	recorder *MockUserMockRecorder
}

// MockUserMockRecorder is the mock recorder for MockUser.
type MockUserMockRecorder struct {
	mock *MockUser
}

// NewMockUser creates a new mock instance.
func NewMockUser(ctrl *gomock.Controller) *MockUser {
	mock := &MockUser{ctrl: ctrl}
	mock.recorder = &MockUserMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUser) EXPECT() *MockUserMockRecorder {
	return m.recorder
}

// CrateUser mocks base method.
func (m *MockUser) CrateUser(ctx context.Context, user *model.User) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CrateUser", ctx, user)
	ret0, _ := ret[0].(error)
	return ret0
}

// CrateUser indicates an expected call of CrateUser.
func (mr *MockUserMockRecorder) CrateUser(ctx, user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CrateUser", reflect.TypeOf((*MockUser)(nil).CrateUser), ctx, user)
}

// GetUser mocks base method.
func (m *MockUser) GetUser(ctx context.Context, id int64) (*model.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUser", ctx, id)
	ret0, _ := ret[0].(*model.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUser indicates an expected call of GetUser.
func (mr *MockUserMockRecorder) GetUser(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockUser)(nil).GetUser), ctx, id)
}

// Init mocks base method.
func (m *MockUser) Init(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockUserMockRecorder) Init(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockUser)(nil).Init), ctx)
}

// MockSource is a mock of Source interface.
type MockSource struct {
	ctrl     *gomock.Controller
	recorder *MockSourceMockRecorder
}

// MockSourceMockRecorder is the mock recorder for MockSource.
type MockSourceMockRecorder struct {
	mock *MockSource
}

// NewMockSource creates a new mock instance.
func NewMockSource(ctrl *gomock.Controller) *MockSource {
	mock := &MockSource{ctrl: ctrl}
	mock.recorder = &MockSourceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSource) EXPECT() *MockSourceMockRecorder {
	return m.recorder
}

// AddSource mocks base method.
func (m *MockSource) AddSource(ctx context.Context, source *model.Source) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSource", ctx, source)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSource indicates an expected call of AddSource.
func (mr *MockSourceMockRecorder) AddSource(ctx, source interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSource", reflect.TypeOf((*MockSource)(nil).AddSource), ctx, source)
}

// Delete mocks base method.
func (m *MockSource) Delete(ctx context.Context, id uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockSourceMockRecorder) Delete(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSource)(nil).Delete), ctx, id)
}

// GetSource mocks base method.
func (m *MockSource) GetSource(ctx context.Context, id uint) (*model.Source, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSource", ctx, id)
	ret0, _ := ret[0].(*model.Source)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSource indicates an expected call of GetSource.
func (mr *MockSourceMockRecorder) GetSource(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSource", reflect.TypeOf((*MockSource)(nil).GetSource), ctx, id)
}

// GetSourceByURL mocks base method.
func (m *MockSource) GetSourceByURL(ctx context.Context, url string) (*model.Source, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSourceByURL", ctx, url)
	ret0, _ := ret[0].(*model.Source)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSourceByURL indicates an expected call of GetSourceByURL.
func (mr *MockSourceMockRecorder) GetSourceByURL(ctx, url interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceByURL", reflect.TypeOf((*MockSource)(nil).GetSourceByURL), ctx, url)
}

// GetSources mocks base method.
func (m *MockSource) GetSources(ctx context.Context) ([]*model.Source, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSources", ctx)
	ret0, _ := ret[0].([]*model.Source)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSources indicates an expected call of GetSources.
func (mr *MockSourceMockRecorder) GetSources(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSources", reflect.TypeOf((*MockSource)(nil).GetSources), ctx)
}

// Init mocks base method.
func (m *MockSource) Init(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockSourceMockRecorder) Init(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSource)(nil).Init), ctx)
}

// UpsertSource mocks base method.
func (m *MockSource) UpsertSource(ctx context.Context, sourceID uint, newSource *model.Source) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertSource", ctx, sourceID, newSource)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertSource indicates an expected call of UpsertSource.
func (mr *MockSourceMockRecorder) UpsertSource(ctx, sourceID, newSource interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertSource", reflect.TypeOf((*MockSource)(nil).UpsertSource), ctx, sourceID, newSource)
}

// MockSubscription is a mock of Subscription interface.
type MockSubscription struct {
	ctrl     *gomock.Controller
	recorder *MockSubscriptionMockRecorder
}

// MockSubscriptionMockRecorder is the mock recorder for MockSubscription.
type MockSubscriptionMockRecorder struct {
	mock *MockSubscription
}

// NewMockSubscription creates a new mock instance.
func NewMockSubscription(ctrl *gomock.Controller) *MockSubscription {
	mock := &MockSubscription{ctrl: ctrl}
	mock.recorder = &MockSubscriptionMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSubscription) EXPECT() *MockSubscriptionMockRecorder {
	return m.recorder
}

// AddSubscription mocks base method.
func (m *MockSubscription) AddSubscription(ctx context.Context, subscription *model.Subscribe) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSubscription", ctx, subscription)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSubscription indicates an expected call of AddSubscription.
func (mr *MockSubscriptionMockRecorder) AddSubscription(ctx, subscription interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSubscription", reflect.TypeOf((*MockSubscription)(nil).AddSubscription), ctx, subscription)
}

// CountSourceSubscriptions mocks base method.
func (m *MockSubscription) CountSourceSubscriptions(ctx context.Context, sourceID uint) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountSourceSubscriptions", ctx, sourceID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountSourceSubscriptions indicates an expected call of CountSourceSubscriptions.
func (mr *MockSubscriptionMockRecorder) CountSourceSubscriptions(ctx, sourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountSourceSubscriptions", reflect.TypeOf((*MockSubscription)(nil).CountSourceSubscriptions), ctx, sourceID)
}

// CountSubscriptions mocks base method.
func (m *MockSubscription) CountSubscriptions(ctx context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountSubscriptions", ctx)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountSubscriptions indicates an expected call of CountSubscriptions.
func (mr *MockSubscriptionMockRecorder) CountSubscriptions(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountSubscriptions", reflect.TypeOf((*MockSubscription)(nil).CountSubscriptions), ctx)
}

// DeleteSubscription mocks base method.
func (m *MockSubscription) DeleteSubscription(ctx context.Context, userID int64, sourceID uint) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubscription", ctx, userID, sourceID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSubscription indicates an expected call of DeleteSubscription.
func (mr *MockSubscriptionMockRecorder) DeleteSubscription(ctx, userID, sourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubscription", reflect.TypeOf((*MockSubscription)(nil).DeleteSubscription), ctx, userID, sourceID)
}

// GetSubscription mocks base method.
func (m *MockSubscription) GetSubscription(ctx context.Context, userID int64, sourceID uint) (*model.Subscribe, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubscription", ctx, userID, sourceID)
	ret0, _ := ret[0].(*model.Subscribe)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscription indicates an expected call of GetSubscription.
func (mr *MockSubscriptionMockRecorder) GetSubscription(ctx, userID, sourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscription", reflect.TypeOf((*MockSubscription)(nil).GetSubscription), ctx, userID, sourceID)
}

// GetSubscriptionsBySourceID mocks base method.
func (m *MockSubscription) GetSubscriptionsBySourceID(ctx context.Context, sourceID uint, opts *storage.GetSubscriptionsOptions) (*storage.GetSubscriptionsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubscriptionsBySourceID", ctx, sourceID, opts)
	ret0, _ := ret[0].(*storage.GetSubscriptionsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscriptionsBySourceID indicates an expected call of GetSubscriptionsBySourceID.
func (mr *MockSubscriptionMockRecorder) GetSubscriptionsBySourceID(ctx, sourceID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionsBySourceID", reflect.TypeOf((*MockSubscription)(nil).GetSubscriptionsBySourceID), ctx, sourceID, opts)
}

// GetSubscriptionsByUserID mocks base method.
func (m *MockSubscription) GetSubscriptionsByUserID(ctx context.Context, userID int64, opts *storage.GetSubscriptionsOptions) (*storage.GetSubscriptionsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubscriptionsByUserID", ctx, userID, opts)
	ret0, _ := ret[0].(*storage.GetSubscriptionsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscriptionsByUserID indicates an expected call of GetSubscriptionsByUserID.
func (mr *MockSubscriptionMockRecorder) GetSubscriptionsByUserID(ctx, userID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionsByUserID", reflect.TypeOf((*MockSubscription)(nil).GetSubscriptionsByUserID), ctx, userID, opts)
}

// Init mocks base method.
func (m *MockSubscription) Init(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockSubscriptionMockRecorder) Init(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSubscription)(nil).Init), ctx)
}

// SubscriptionExist mocks base method.
func (m *MockSubscription) SubscriptionExist(ctx context.Context, userID int64, sourceID uint) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscriptionExist", ctx, userID, sourceID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscriptionExist indicates an expected call of SubscriptionExist.
func (mr *MockSubscriptionMockRecorder) SubscriptionExist(ctx, userID, sourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscriptionExist", reflect.TypeOf((*MockSubscription)(nil).SubscriptionExist), ctx, userID, sourceID)
}

// UpdateSubscription mocks base method.
func (m *MockSubscription) UpdateSubscription(ctx context.Context, userID int64, sourceID uint, newSubscription *model.Subscribe) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSubscription", ctx, userID, sourceID, newSubscription)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSubscription indicates an expected call of UpdateSubscription.
func (mr *MockSubscriptionMockRecorder) UpdateSubscription(ctx, userID, sourceID, newSubscription interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubscription", reflect.TypeOf((*MockSubscription)(nil).UpdateSubscription), ctx, userID, sourceID, newSubscription)
}

// UpsertSubscription mocks base method.
func (m *MockSubscription) UpsertSubscription(ctx context.Context, userID int64, sourceID uint, newSubscription *model.Subscribe) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertSubscription", ctx, userID, sourceID, newSubscription)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertSubscription indicates an expected call of UpsertSubscription.
func (mr *MockSubscriptionMockRecorder) UpsertSubscription(ctx, userID, sourceID, newSubscription interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertSubscription", reflect.TypeOf((*MockSubscription)(nil).UpsertSubscription), ctx, userID, sourceID, newSubscription)
}

// MockContent is a mock of Content interface.
type MockContent struct {
	ctrl     *gomock.Controller
	recorder *MockContentMockRecorder
}

// MockContentMockRecorder is the mock recorder for MockContent.
type MockContentMockRecorder struct {
	mock *MockContent
}

// NewMockContent creates a new mock instance.
func NewMockContent(ctrl *gomock.Controller) *MockContent {
	mock := &MockContent{ctrl: ctrl}
	mock.recorder = &MockContentMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockContent) EXPECT() *MockContentMockRecorder {
	return m.recorder
}

// AddContent mocks base method.
func (m *MockContent) AddContent(ctx context.Context, content *model.Content) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddContent", ctx, content)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddContent indicates an expected call of AddContent.
func (mr *MockContentMockRecorder) AddContent(ctx, content interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockContent)(nil).AddContent), ctx, content)
}

// DeleteSourceContents mocks base method.
func (m *MockContent) DeleteSourceContents(ctx context.Context, sourceID uint) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSourceContents", ctx, sourceID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSourceContents indicates an expected call of DeleteSourceContents.
func (mr *MockContentMockRecorder) DeleteSourceContents(ctx, sourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSourceContents", reflect.TypeOf((*MockContent)(nil).DeleteSourceContents), ctx, sourceID)
}

// HashIDExist mocks base method.
func (m *MockContent) HashIDExist(ctx context.Context, hashID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HashIDExist", ctx, hashID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HashIDExist indicates an expected call of HashIDExist.
func (mr *MockContentMockRecorder) HashIDExist(ctx, hashID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashIDExist", reflect.TypeOf((*MockContent)(nil).HashIDExist), ctx, hashID)
}

// Init mocks base method.
func (m *MockContent) Init(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockContentMockRecorder) Init(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockContent)(nil).Init), ctx)
}