mockport

package
v0.0.0-...-06621f0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 20, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAuthService 

type MockAuthService struct {
	mock.Mock
}

MockAuthService is an autogenerated mock type for the AuthService type

func NewMockAuthService 

func NewMockAuthService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAuthService

NewMockAuthService creates a new instance of MockAuthService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAuthService) EXPECT 

func (_m *MockAuthService) EXPECT() *MockAuthService_Expecter

func (*MockAuthService) FinishGoogleSignIn 

func (_m *MockAuthService) FinishGoogleSignIn(_a0 context.Context, _a1 *http.Request) (string, string, error)

FinishGoogleSignIn provides a mock function with given fields: _a0, _a1

func (*MockAuthService) RefreshAppIDToken 

func (_m *MockAuthService) RefreshAppIDToken(ctx context.Context, tokenString string) (*model.AppIDToken, string, error)

RefreshAppIDToken provides a mock function with given fields: ctx, tokenString

func (*MockAuthService) StartGoogleSignIn 

func (_m *MockAuthService) StartGoogleSignIn(_a0 context.Context, _a1 *http.Request) (string, error)

StartGoogleSignIn provides a mock function with given fields: _a0, _a1

func (*MockAuthService) VerifyAppIDToken 

func (_m *MockAuthService) VerifyAppIDToken(_a0 string) (*model.AppIDToken, error)

VerifyAppIDToken provides a mock function with given fields: _a0

type MockAuthService_Expecter 

type MockAuthService_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockAuthService_Expecter) FinishGoogleSignIn 

func (_e *MockAuthService_Expecter) FinishGoogleSignIn(_a0 interface{}, _a1 interface{}) *MockAuthService_FinishGoogleSignIn_Call

FinishGoogleSignIn is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *http.Request

func (*MockAuthService_Expecter) RefreshAppIDToken 

func (_e *MockAuthService_Expecter) RefreshAppIDToken(ctx interface{}, tokenString interface{}) *MockAuthService_RefreshAppIDToken_Call

RefreshAppIDToken is a helper method to define mock.On call

  • ctx context.Context
  • tokenString string

func (*MockAuthService_Expecter) StartGoogleSignIn 

func (_e *MockAuthService_Expecter) StartGoogleSignIn(_a0 interface{}, _a1 interface{}) *MockAuthService_StartGoogleSignIn_Call

StartGoogleSignIn is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *http.Request

func (*MockAuthService_Expecter) VerifyAppIDToken 

func (_e *MockAuthService_Expecter) VerifyAppIDToken(_a0 interface{}) *MockAuthService_VerifyAppIDToken_Call

VerifyAppIDToken is a helper method to define mock.On call

  • _a0 string

type MockAuthService_FinishGoogleSignIn_Call 

type MockAuthService_FinishGoogleSignIn_Call struct {
	*mock.Call
}

MockAuthService_FinishGoogleSignIn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FinishGoogleSignIn'

func (*MockAuthService_FinishGoogleSignIn_Call) Return 

func (_c *MockAuthService_FinishGoogleSignIn_Call) Return(redirectURL string, appToken string, err error) *MockAuthService_FinishGoogleSignIn_Call

func (*MockAuthService_FinishGoogleSignIn_Call) Run 

func (_c *MockAuthService_FinishGoogleSignIn_Call) Run(run func(_a0 context.Context, _a1 *http.Request)) *MockAuthService_FinishGoogleSignIn_Call

func (*MockAuthService_FinishGoogleSignIn_Call) RunAndReturn 

func (_c *MockAuthService_FinishGoogleSignIn_Call) RunAndReturn(run func(context.Context, *http.Request) (string, string, error)) *MockAuthService_FinishGoogleSignIn_Call

type MockAuthService_RefreshAppIDToken_Call 

type MockAuthService_RefreshAppIDToken_Call struct {
	*mock.Call
}

MockAuthService_RefreshAppIDToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshAppIDToken'

func (*MockAuthService_RefreshAppIDToken_Call) Return 

func (_c *MockAuthService_RefreshAppIDToken_Call) Return(newToken *model.AppIDToken, newTokenString string, err error) *MockAuthService_RefreshAppIDToken_Call

func (*MockAuthService_RefreshAppIDToken_Call) Run 

func (_c *MockAuthService_RefreshAppIDToken_Call) Run(run func(ctx context.Context, tokenString string)) *MockAuthService_RefreshAppIDToken_Call

func (*MockAuthService_RefreshAppIDToken_Call) RunAndReturn 

func (_c *MockAuthService_RefreshAppIDToken_Call) RunAndReturn(run func(context.Context, string) (*model.AppIDToken, string, error)) *MockAuthService_RefreshAppIDToken_Call

type MockAuthService_StartGoogleSignIn_Call 

type MockAuthService_StartGoogleSignIn_Call struct {
	*mock.Call
}

MockAuthService_StartGoogleSignIn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartGoogleSignIn'

func (*MockAuthService_StartGoogleSignIn_Call) Return 

func (_c *MockAuthService_StartGoogleSignIn_Call) Return(redirectURL string, err error) *MockAuthService_StartGoogleSignIn_Call

func (*MockAuthService_StartGoogleSignIn_Call) Run 

func (_c *MockAuthService_StartGoogleSignIn_Call) Run(run func(_a0 context.Context, _a1 *http.Request)) *MockAuthService_StartGoogleSignIn_Call

func (*MockAuthService_StartGoogleSignIn_Call) RunAndReturn 

func (_c *MockAuthService_StartGoogleSignIn_Call) RunAndReturn(run func(context.Context, *http.Request) (string, error)) *MockAuthService_StartGoogleSignIn_Call

type MockAuthService_VerifyAppIDToken_Call 

type MockAuthService_VerifyAppIDToken_Call struct {
	*mock.Call
}

MockAuthService_VerifyAppIDToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyAppIDToken'

func (*MockAuthService_VerifyAppIDToken_Call) Return 

func (_c *MockAuthService_VerifyAppIDToken_Call) Return(_a0 *model.AppIDToken, _a1 error) *MockAuthService_VerifyAppIDToken_Call

func (*MockAuthService_VerifyAppIDToken_Call) Run 

func (_c *MockAuthService_VerifyAppIDToken_Call) Run(run func(_a0 string)) *MockAuthService_VerifyAppIDToken_Call

func (*MockAuthService_VerifyAppIDToken_Call) RunAndReturn 

func (_c *MockAuthService_VerifyAppIDToken_Call) RunAndReturn(run func(string) (*model.AppIDToken, error)) *MockAuthService_VerifyAppIDToken_Call

type MockCollaborationRepository 

type MockCollaborationRepository struct {
	mock.Mock
}

MockCollaborationRepository is an autogenerated mock type for the CollaborationRepository type

func NewMockCollaborationRepository 

func NewMockCollaborationRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCollaborationRepository

NewMockCollaborationRepository creates a new instance of MockCollaborationRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockCollaborationRepository) Create 

func (_m *MockCollaborationRepository) Create(ctx context.Context, memoID uuid.UUID, userID uuid.UUID) (*ent.Collaboration, error)

Create provides a mock function with given fields: ctx, memoID, userID

func (*MockCollaborationRepository) Delete 

func (_m *MockCollaborationRepository) Delete(ctx context.Context, memoID uuid.UUID, userID uuid.UUID) error

Delete provides a mock function with given fields: ctx, memoID, userID

func (*MockCollaborationRepository) DeleteAllByMemoID 

func (_m *MockCollaborationRepository) DeleteAllByMemoID(ctx context.Context, memoID uuid.UUID) (int, error)

DeleteAllByMemoID provides a mock function with given fields: ctx, memoID

func (*MockCollaborationRepository) EXPECT 

func (_m *MockCollaborationRepository) EXPECT() *MockCollaborationRepository_Expecter

func (*MockCollaborationRepository) Find 

func (_m *MockCollaborationRepository) Find(ctx context.Context, memoID uuid.UUID, userID uuid.UUID) (*ent.Collaboration, error)

Find provides a mock function with given fields: ctx, memoID, userID

func (*MockCollaborationRepository) UpdateApprovedStatus 

func (_m *MockCollaborationRepository) UpdateApprovedStatus(ctx context.Context, memoID uuid.UUID, userID uuid.UUID, approve bool) (*ent.Collaboration, error)

UpdateApprovedStatus provides a mock function with given fields: ctx, memoID, userID, approve

type MockCollaborationRepository_Create_Call 

type MockCollaborationRepository_Create_Call struct {
	*mock.Call
}

MockCollaborationRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockCollaborationRepository_Create_Call) Return 

func (_c *MockCollaborationRepository_Create_Call) Return(_a0 *ent.Collaboration, _a1 error) *MockCollaborationRepository_Create_Call

func (*MockCollaborationRepository_Create_Call) Run 

func (_c *MockCollaborationRepository_Create_Call) Run(run func(ctx context.Context, memoID uuid.UUID, userID uuid.UUID)) *MockCollaborationRepository_Create_Call

func (*MockCollaborationRepository_Create_Call) RunAndReturn 

func (_c *MockCollaborationRepository_Create_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID) (*ent.Collaboration, error)) *MockCollaborationRepository_Create_Call

type MockCollaborationRepository_DeleteAllByMemoID_Call 

type MockCollaborationRepository_DeleteAllByMemoID_Call struct {
	*mock.Call
}

MockCollaborationRepository_DeleteAllByMemoID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllByMemoID'

func (*MockCollaborationRepository_DeleteAllByMemoID_Call) Return 

func (_c *MockCollaborationRepository_DeleteAllByMemoID_Call) Return(count int, err error) *MockCollaborationRepository_DeleteAllByMemoID_Call

func (*MockCollaborationRepository_DeleteAllByMemoID_Call) Run 

func (_c *MockCollaborationRepository_DeleteAllByMemoID_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockCollaborationRepository_DeleteAllByMemoID_Call

func (*MockCollaborationRepository_DeleteAllByMemoID_Call) RunAndReturn 

func (_c *MockCollaborationRepository_DeleteAllByMemoID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (int, error)) *MockCollaborationRepository_DeleteAllByMemoID_Call

type MockCollaborationRepository_Delete_Call 

type MockCollaborationRepository_Delete_Call struct {
	*mock.Call
}

MockCollaborationRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockCollaborationRepository_Delete_Call) Return 

func (_c *MockCollaborationRepository_Delete_Call) Return(_a0 error) *MockCollaborationRepository_Delete_Call

func (*MockCollaborationRepository_Delete_Call) Run 

func (_c *MockCollaborationRepository_Delete_Call) Run(run func(ctx context.Context, memoID uuid.UUID, userID uuid.UUID)) *MockCollaborationRepository_Delete_Call

func (*MockCollaborationRepository_Delete_Call) RunAndReturn 

func (_c *MockCollaborationRepository_Delete_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID) error) *MockCollaborationRepository_Delete_Call

type MockCollaborationRepository_Expecter 

type MockCollaborationRepository_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockCollaborationRepository_Expecter) Create 

func (_e *MockCollaborationRepository_Expecter) Create(ctx interface{}, memoID interface{}, userID interface{}) *MockCollaborationRepository_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • userID uuid.UUID

func (*MockCollaborationRepository_Expecter) Delete 

func (_e *MockCollaborationRepository_Expecter) Delete(ctx interface{}, memoID interface{}, userID interface{}) *MockCollaborationRepository_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • userID uuid.UUID

func (*MockCollaborationRepository_Expecter) DeleteAllByMemoID 

func (_e *MockCollaborationRepository_Expecter) DeleteAllByMemoID(ctx interface{}, memoID interface{}) *MockCollaborationRepository_DeleteAllByMemoID_Call

DeleteAllByMemoID is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockCollaborationRepository_Expecter) Find 

func (_e *MockCollaborationRepository_Expecter) Find(ctx interface{}, memoID interface{}, userID interface{}) *MockCollaborationRepository_Find_Call

Find is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • userID uuid.UUID

func (*MockCollaborationRepository_Expecter) UpdateApprovedStatus 

func (_e *MockCollaborationRepository_Expecter) UpdateApprovedStatus(ctx interface{}, memoID interface{}, userID interface{}, approve interface{}) *MockCollaborationRepository_UpdateApprovedStatus_Call

UpdateApprovedStatus is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • userID uuid.UUID
  • approve bool

type MockCollaborationRepository_Find_Call 

type MockCollaborationRepository_Find_Call struct {
	*mock.Call
}

MockCollaborationRepository_Find_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Find'

func (*MockCollaborationRepository_Find_Call) Return 

func (_c *MockCollaborationRepository_Find_Call) Return(_a0 *ent.Collaboration, _a1 error) *MockCollaborationRepository_Find_Call

func (*MockCollaborationRepository_Find_Call) Run 

func (_c *MockCollaborationRepository_Find_Call) Run(run func(ctx context.Context, memoID uuid.UUID, userID uuid.UUID)) *MockCollaborationRepository_Find_Call

func (*MockCollaborationRepository_Find_Call) RunAndReturn 

func (_c *MockCollaborationRepository_Find_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID) (*ent.Collaboration, error)) *MockCollaborationRepository_Find_Call

type MockCollaborationRepository_UpdateApprovedStatus_Call 

type MockCollaborationRepository_UpdateApprovedStatus_Call struct {
	*mock.Call
}

MockCollaborationRepository_UpdateApprovedStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApprovedStatus'

func (*MockCollaborationRepository_UpdateApprovedStatus_Call) Return 

func (_c *MockCollaborationRepository_UpdateApprovedStatus_Call) Return(_a0 *ent.Collaboration, _a1 error) *MockCollaborationRepository_UpdateApprovedStatus_Call

func (*MockCollaborationRepository_UpdateApprovedStatus_Call) Run 

func (_c *MockCollaborationRepository_UpdateApprovedStatus_Call) Run(run func(ctx context.Context, memoID uuid.UUID, userID uuid.UUID, approve bool)) *MockCollaborationRepository_UpdateApprovedStatus_Call

func (*MockCollaborationRepository_UpdateApprovedStatus_Call) RunAndReturn 

func (_c *MockCollaborationRepository_UpdateApprovedStatus_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID, bool) (*ent.Collaboration, error)) *MockCollaborationRepository_UpdateApprovedStatus_Call

type MockGoogleClient 

type MockGoogleClient struct {
	mock.Mock
}

MockGoogleClient is an autogenerated mock type for the GoogleClient type

func NewMockGoogleClient 

func NewMockGoogleClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGoogleClient

NewMockGoogleClient creates a new instance of MockGoogleClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockGoogleClient) EXPECT 

func (_m *MockGoogleClient) EXPECT() *MockGoogleClient_Expecter

func (*MockGoogleClient) ExchangeAuthCode 

func (_m *MockGoogleClient) ExchangeAuthCode(ctx context.Context, code string, redirectURI string) (model.GoogleTokenResponse, error)

ExchangeAuthCode provides a mock function with given fields: ctx, code, redirectURI

type MockGoogleClient_ExchangeAuthCode_Call 

type MockGoogleClient_ExchangeAuthCode_Call struct {
	*mock.Call
}

MockGoogleClient_ExchangeAuthCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExchangeAuthCode'

func (*MockGoogleClient_ExchangeAuthCode_Call) Return 

func (_c *MockGoogleClient_ExchangeAuthCode_Call) Return(_a0 model.GoogleTokenResponse, _a1 error) *MockGoogleClient_ExchangeAuthCode_Call

func (*MockGoogleClient_ExchangeAuthCode_Call) Run 

func (_c *MockGoogleClient_ExchangeAuthCode_Call) Run(run func(ctx context.Context, code string, redirectURI string)) *MockGoogleClient_ExchangeAuthCode_Call

func (*MockGoogleClient_ExchangeAuthCode_Call) RunAndReturn 

func (_c *MockGoogleClient_ExchangeAuthCode_Call) RunAndReturn(run func(context.Context, string, string) (model.GoogleTokenResponse, error)) *MockGoogleClient_ExchangeAuthCode_Call

type MockGoogleClient_Expecter 

type MockGoogleClient_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockGoogleClient_Expecter) ExchangeAuthCode 

func (_e *MockGoogleClient_Expecter) ExchangeAuthCode(ctx interface{}, code interface{}, redirectURI interface{}) *MockGoogleClient_ExchangeAuthCode_Call

ExchangeAuthCode is a helper method to define mock.On call

  • ctx context.Context
  • code string
  • redirectURI string

type MockJWTClient 

type MockJWTClient struct {
	mock.Mock
}

MockJWTClient is an autogenerated mock type for the JWTClient type

func NewMockJWTClient 

func NewMockJWTClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockJWTClient

NewMockJWTClient creates a new instance of MockJWTClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockJWTClient) EXPECT 

func (_m *MockJWTClient) EXPECT() *MockJWTClient_Expecter

func (*MockJWTClient) ParseGoogleIDTokenUnverified 

func (_m *MockJWTClient) ParseGoogleIDTokenUnverified(tokenString string) (*model.GoogleIDToken, error)

ParseGoogleIDTokenUnverified provides a mock function with given fields: tokenString

func (*MockJWTClient) SignAppIDToken 

func (_m *MockJWTClient) SignAppIDToken(_a0 *model.AppIDToken) (*model.AppIDToken, string, error)

SignAppIDToken provides a mock function with given fields: _a0

func (*MockJWTClient) VerifyAppIDToken 

func (_m *MockJWTClient) VerifyAppIDToken(tokenString string) (*model.AppIDToken, error)

VerifyAppIDToken provides a mock function with given fields: tokenString

type MockJWTClient_Expecter 

type MockJWTClient_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockJWTClient_Expecter) ParseGoogleIDTokenUnverified 

func (_e *MockJWTClient_Expecter) ParseGoogleIDTokenUnverified(tokenString interface{}) *MockJWTClient_ParseGoogleIDTokenUnverified_Call

ParseGoogleIDTokenUnverified is a helper method to define mock.On call

  • tokenString string

func (*MockJWTClient_Expecter) SignAppIDToken 

func (_e *MockJWTClient_Expecter) SignAppIDToken(_a0 interface{}) *MockJWTClient_SignAppIDToken_Call

SignAppIDToken is a helper method to define mock.On call

  • _a0 *model.AppIDToken

func (*MockJWTClient_Expecter) VerifyAppIDToken 

func (_e *MockJWTClient_Expecter) VerifyAppIDToken(tokenString interface{}) *MockJWTClient_VerifyAppIDToken_Call

VerifyAppIDToken is a helper method to define mock.On call

  • tokenString string

type MockJWTClient_ParseGoogleIDTokenUnverified_Call 

type MockJWTClient_ParseGoogleIDTokenUnverified_Call struct {
	*mock.Call
}

MockJWTClient_ParseGoogleIDTokenUnverified_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParseGoogleIDTokenUnverified'

func (*MockJWTClient_ParseGoogleIDTokenUnverified_Call) Return 

func (_c *MockJWTClient_ParseGoogleIDTokenUnverified_Call) Return(_a0 *model.GoogleIDToken, _a1 error) *MockJWTClient_ParseGoogleIDTokenUnverified_Call

func (*MockJWTClient_ParseGoogleIDTokenUnverified_Call) Run 

func (_c *MockJWTClient_ParseGoogleIDTokenUnverified_Call) Run(run func(tokenString string)) *MockJWTClient_ParseGoogleIDTokenUnverified_Call

func (*MockJWTClient_ParseGoogleIDTokenUnverified_Call) RunAndReturn 

func (_c *MockJWTClient_ParseGoogleIDTokenUnverified_Call) RunAndReturn(run func(string) (*model.GoogleIDToken, error)) *MockJWTClient_ParseGoogleIDTokenUnverified_Call

type MockJWTClient_SignAppIDToken_Call 

type MockJWTClient_SignAppIDToken_Call struct {
	*mock.Call
}

MockJWTClient_SignAppIDToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignAppIDToken'

func (*MockJWTClient_SignAppIDToken_Call) Return 

func (_c *MockJWTClient_SignAppIDToken_Call) Return(token *model.AppIDToken, tokenString string, err error) *MockJWTClient_SignAppIDToken_Call

func (*MockJWTClient_SignAppIDToken_Call) Run 

func (_c *MockJWTClient_SignAppIDToken_Call) Run(run func(_a0 *model.AppIDToken)) *MockJWTClient_SignAppIDToken_Call

func (*MockJWTClient_SignAppIDToken_Call) RunAndReturn 

func (_c *MockJWTClient_SignAppIDToken_Call) RunAndReturn(run func(*model.AppIDToken) (*model.AppIDToken, string, error)) *MockJWTClient_SignAppIDToken_Call

type MockJWTClient_VerifyAppIDToken_Call 

type MockJWTClient_VerifyAppIDToken_Call struct {
	*mock.Call
}

MockJWTClient_VerifyAppIDToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyAppIDToken'

func (*MockJWTClient_VerifyAppIDToken_Call) Return 

func (_c *MockJWTClient_VerifyAppIDToken_Call) Return(_a0 *model.AppIDToken, _a1 error) *MockJWTClient_VerifyAppIDToken_Call

func (*MockJWTClient_VerifyAppIDToken_Call) Run 

func (_c *MockJWTClient_VerifyAppIDToken_Call) Run(run func(tokenString string)) *MockJWTClient_VerifyAppIDToken_Call

func (*MockJWTClient_VerifyAppIDToken_Call) RunAndReturn 

func (_c *MockJWTClient_VerifyAppIDToken_Call) RunAndReturn(run func(string) (*model.AppIDToken, error)) *MockJWTClient_VerifyAppIDToken_Call

type MockKVRepository 

type MockKVRepository struct {
	mock.Mock
}

MockKVRepository is an autogenerated mock type for the KVRepository type

func NewMockKVRepository 

func NewMockKVRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockKVRepository

NewMockKVRepository creates a new instance of MockKVRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockKVRepository) Delete 

func (_m *MockKVRepository) Delete(ctx context.Context, keys ...string) (int64, error)

Delete provides a mock function with given fields: ctx, keys

func (*MockKVRepository) EXPECT 

func (_m *MockKVRepository) EXPECT() *MockKVRepository_Expecter

func (*MockKVRepository) Get 

func (_m *MockKVRepository) Get(ctx context.Context, key string) (string, error)

Get provides a mock function with given fields: ctx, key

func (*MockKVRepository) GetThenDelete 

func (_m *MockKVRepository) GetThenDelete(ctx context.Context, key string) (string, error)

GetThenDelete provides a mock function with given fields: ctx, key

func (*MockKVRepository) Set 

func (_m *MockKVRepository) Set(ctx context.Context, key string, val string, exp time.Duration) error

Set provides a mock function with given fields: ctx, key, val, exp

type MockKVRepository_Delete_Call 

type MockKVRepository_Delete_Call struct {
	*mock.Call
}

MockKVRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockKVRepository_Delete_Call) Return 

func (_c *MockKVRepository_Delete_Call) Return(delCount int64, err error) *MockKVRepository_Delete_Call

func (*MockKVRepository_Delete_Call) Run 

func (_c *MockKVRepository_Delete_Call) Run(run func(ctx context.Context, keys ...string)) *MockKVRepository_Delete_Call

func (*MockKVRepository_Delete_Call) RunAndReturn 

func (_c *MockKVRepository_Delete_Call) RunAndReturn(run func(context.Context, ...string) (int64, error)) *MockKVRepository_Delete_Call

type MockKVRepository_Expecter 

type MockKVRepository_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockKVRepository_Expecter) Delete 

func (_e *MockKVRepository_Expecter) Delete(ctx interface{}, keys ...interface{}) *MockKVRepository_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*MockKVRepository_Expecter) Get 

func (_e *MockKVRepository_Expecter) Get(ctx interface{}, key interface{}) *MockKVRepository_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockKVRepository_Expecter) GetThenDelete 

func (_e *MockKVRepository_Expecter) GetThenDelete(ctx interface{}, key interface{}) *MockKVRepository_GetThenDelete_Call

GetThenDelete is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockKVRepository_Expecter) Set 

func (_e *MockKVRepository_Expecter) Set(ctx interface{}, key interface{}, val interface{}, exp interface{}) *MockKVRepository_Set_Call

Set is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • val string
  • exp time.Duration

type MockKVRepository_GetThenDelete_Call 

type MockKVRepository_GetThenDelete_Call struct {
	*mock.Call
}

MockKVRepository_GetThenDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetThenDelete'

func (*MockKVRepository_GetThenDelete_Call) Return 

func (_c *MockKVRepository_GetThenDelete_Call) Return(_a0 string, _a1 error) *MockKVRepository_GetThenDelete_Call

func (*MockKVRepository_GetThenDelete_Call) Run 

func (_c *MockKVRepository_GetThenDelete_Call) Run(run func(ctx context.Context, key string)) *MockKVRepository_GetThenDelete_Call

func (*MockKVRepository_GetThenDelete_Call) RunAndReturn 

func (_c *MockKVRepository_GetThenDelete_Call) RunAndReturn(run func(context.Context, string) (string, error)) *MockKVRepository_GetThenDelete_Call

type MockKVRepository_Get_Call 

type MockKVRepository_Get_Call struct {
	*mock.Call
}

MockKVRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockKVRepository_Get_Call) Return 

func (_c *MockKVRepository_Get_Call) Return(_a0 string, _a1 error) *MockKVRepository_Get_Call

func (*MockKVRepository_Get_Call) Run 

func (_c *MockKVRepository_Get_Call) Run(run func(ctx context.Context, key string)) *MockKVRepository_Get_Call

func (*MockKVRepository_Get_Call) RunAndReturn 

func (_c *MockKVRepository_Get_Call) RunAndReturn(run func(context.Context, string) (string, error)) *MockKVRepository_Get_Call

type MockKVRepository_Set_Call 

type MockKVRepository_Set_Call struct {
	*mock.Call
}

MockKVRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'

func (*MockKVRepository_Set_Call) Return 

func (_c *MockKVRepository_Set_Call) Return(_a0 error) *MockKVRepository_Set_Call

func (*MockKVRepository_Set_Call) Run 

func (_c *MockKVRepository_Set_Call) Run(run func(ctx context.Context, key string, val string, exp time.Duration)) *MockKVRepository_Set_Call

func (*MockKVRepository_Set_Call) RunAndReturn 

func (_c *MockKVRepository_Set_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockKVRepository_Set_Call

type MockMemoRepository 

type MockMemoRepository struct {
	mock.Mock
}

MockMemoRepository is an autogenerated mock type for the MemoRepository type

func NewMockMemoRepository 

func NewMockMemoRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMemoRepository

NewMockMemoRepository creates a new instance of MockMemoRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMemoRepository) ClearSubscribers 

func (_m *MockMemoRepository) ClearSubscribers(ctx context.Context, memoID uuid.UUID) error

ClearSubscribers provides a mock function with given fields: ctx, memoID

func (*MockMemoRepository) CountByUserIDAndTagNames 

func (_m *MockMemoRepository) CountByUserIDAndTagNames(ctx context.Context, userID uuid.UUID, tags []string) (int, error)

CountByUserIDAndTagNames provides a mock function with given fields: ctx, userID, tags

func (*MockMemoRepository) Create 

func (_m *MockMemoRepository) Create(ctx context.Context, memo *ent.Memo, userID uuid.UUID, tagIDs []int) (*ent.Memo, error)

Create provides a mock function with given fields: ctx, memo, userID, tagIDs

func (*MockMemoRepository) Delete 

func (_m *MockMemoRepository) Delete(ctx context.Context, memoID uuid.UUID) error

Delete provides a mock function with given fields: ctx, memoID

func (*MockMemoRepository) EXPECT 

func (_m *MockMemoRepository) EXPECT() *MockMemoRepository_Expecter

func (*MockMemoRepository) FindAllByUserIDAndTagNamesWithEdges 

func (_m *MockMemoRepository) FindAllByUserIDAndTagNamesWithEdges(ctx context.Context, userID uuid.UUID, tags []string, sortParams model.MemoSortParams, pageParams model.PaginationParams) ([]*ent.Memo, error)

FindAllByUserIDAndTagNamesWithEdges provides a mock function with given fields: ctx, userID, tags, sortParams, pageParams

func (*MockMemoRepository) FindAllByUserIDWithEdges 

func (_m *MockMemoRepository) FindAllByUserIDWithEdges(ctx context.Context, userID uuid.UUID, sortParams model.MemoSortParams, pageParams model.PaginationParams) ([]*ent.Memo, error)

FindAllByUserIDWithEdges provides a mock function with given fields: ctx, userID, sortParams, pageParams

func (*MockMemoRepository) FindByID 

func (_m *MockMemoRepository) FindByID(ctx context.Context, memoID uuid.UUID) (*ent.Memo, error)

FindByID provides a mock function with given fields: ctx, memoID

func (*MockMemoRepository) FindByIDWithEdges 

func (_m *MockMemoRepository) FindByIDWithEdges(ctx context.Context, memoID uuid.UUID) (*ent.Memo, error)

FindByIDWithEdges provides a mock function with given fields: ctx, memoID

func (*MockMemoRepository) RegisterSubscriber 

func (_m *MockMemoRepository) RegisterSubscriber(ctx context.Context, memoID uuid.UUID, userID uuid.UUID) error

RegisterSubscriber provides a mock function with given fields: ctx, memoID, userID

func (*MockMemoRepository) ReplaceTags 

func (_m *MockMemoRepository) ReplaceTags(ctx context.Context, memoID uuid.UUID, tagIDs []int, updateTime bool) error

ReplaceTags provides a mock function with given fields: ctx, memoID, tagIDs, updateTime

func (*MockMemoRepository) UnregisterSubscriber 

func (_m *MockMemoRepository) UnregisterSubscriber(ctx context.Context, memoID uuid.UUID, userID uuid.UUID) error

UnregisterSubscriber provides a mock function with given fields: ctx, memoID, userID

func (*MockMemoRepository) Update 

func (_m *MockMemoRepository) Update(_a0 context.Context, _a1 *ent.Memo) (*ent.Memo, error)

Update provides a mock function with given fields: _a0, _a1

func (*MockMemoRepository) UpdateIsPublish 

func (_m *MockMemoRepository) UpdateIsPublish(ctx context.Context, memoID uuid.UUID, isPublish bool) (*ent.Memo, error)

UpdateIsPublish provides a mock function with given fields: ctx, memoID, isPublish

type MockMemoRepository_ClearSubscribers_Call 

type MockMemoRepository_ClearSubscribers_Call struct {
	*mock.Call
}

MockMemoRepository_ClearSubscribers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearSubscribers'

func (*MockMemoRepository_ClearSubscribers_Call) Return 

func (_c *MockMemoRepository_ClearSubscribers_Call) Return(_a0 error) *MockMemoRepository_ClearSubscribers_Call

func (*MockMemoRepository_ClearSubscribers_Call) Run 

func (_c *MockMemoRepository_ClearSubscribers_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockMemoRepository_ClearSubscribers_Call

func (*MockMemoRepository_ClearSubscribers_Call) RunAndReturn 

func (_c *MockMemoRepository_ClearSubscribers_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockMemoRepository_ClearSubscribers_Call

type MockMemoRepository_CountByUserIDAndTagNames_Call 

type MockMemoRepository_CountByUserIDAndTagNames_Call struct {
	*mock.Call
}

MockMemoRepository_CountByUserIDAndTagNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByUserIDAndTagNames'

func (*MockMemoRepository_CountByUserIDAndTagNames_Call) Return 

func (_c *MockMemoRepository_CountByUserIDAndTagNames_Call) Return(_a0 int, _a1 error) *MockMemoRepository_CountByUserIDAndTagNames_Call

func (*MockMemoRepository_CountByUserIDAndTagNames_Call) Run 

func (_c *MockMemoRepository_CountByUserIDAndTagNames_Call) Run(run func(ctx context.Context, userID uuid.UUID, tags []string)) *MockMemoRepository_CountByUserIDAndTagNames_Call

func (*MockMemoRepository_CountByUserIDAndTagNames_Call) RunAndReturn 

func (_c *MockMemoRepository_CountByUserIDAndTagNames_Call) RunAndReturn(run func(context.Context, uuid.UUID, []string) (int, error)) *MockMemoRepository_CountByUserIDAndTagNames_Call

type MockMemoRepository_Create_Call 

type MockMemoRepository_Create_Call struct {
	*mock.Call
}

MockMemoRepository_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockMemoRepository_Create_Call) Return 

func (_c *MockMemoRepository_Create_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoRepository_Create_Call

func (*MockMemoRepository_Create_Call) Run 

func (_c *MockMemoRepository_Create_Call) Run(run func(ctx context.Context, memo *ent.Memo, userID uuid.UUID, tagIDs []int)) *MockMemoRepository_Create_Call

func (*MockMemoRepository_Create_Call) RunAndReturn 

func (_c *MockMemoRepository_Create_Call) RunAndReturn(run func(context.Context, *ent.Memo, uuid.UUID, []int) (*ent.Memo, error)) *MockMemoRepository_Create_Call

type MockMemoRepository_Delete_Call 

type MockMemoRepository_Delete_Call struct {
	*mock.Call
}

MockMemoRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockMemoRepository_Delete_Call) Return 

func (_c *MockMemoRepository_Delete_Call) Return(_a0 error) *MockMemoRepository_Delete_Call

func (*MockMemoRepository_Delete_Call) Run 

func (_c *MockMemoRepository_Delete_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockMemoRepository_Delete_Call

func (*MockMemoRepository_Delete_Call) RunAndReturn 

func (_c *MockMemoRepository_Delete_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockMemoRepository_Delete_Call

type MockMemoRepository_Expecter 

type MockMemoRepository_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMemoRepository_Expecter) ClearSubscribers 

func (_e *MockMemoRepository_Expecter) ClearSubscribers(ctx interface{}, memoID interface{}) *MockMemoRepository_ClearSubscribers_Call

ClearSubscribers is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockMemoRepository_Expecter) CountByUserIDAndTagNames 

func (_e *MockMemoRepository_Expecter) CountByUserIDAndTagNames(ctx interface{}, userID interface{}, tags interface{}) *MockMemoRepository_CountByUserIDAndTagNames_Call

CountByUserIDAndTagNames is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • tags []string

func (*MockMemoRepository_Expecter) Create 

func (_e *MockMemoRepository_Expecter) Create(ctx interface{}, memo interface{}, userID interface{}, tagIDs interface{}) *MockMemoRepository_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • memo *ent.Memo
  • userID uuid.UUID
  • tagIDs []int

func (*MockMemoRepository_Expecter) Delete 

func (_e *MockMemoRepository_Expecter) Delete(ctx interface{}, memoID interface{}) *MockMemoRepository_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockMemoRepository_Expecter) FindAllByUserIDAndTagNamesWithEdges 

func (_e *MockMemoRepository_Expecter) FindAllByUserIDAndTagNamesWithEdges(ctx interface{}, userID interface{}, tags interface{}, sortParams interface{}, pageParams interface{}) *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call

FindAllByUserIDAndTagNamesWithEdges is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • tags []string
  • sortParams model.MemoSortParams
  • pageParams model.PaginationParams

func (*MockMemoRepository_Expecter) FindAllByUserIDWithEdges 

func (_e *MockMemoRepository_Expecter) FindAllByUserIDWithEdges(ctx interface{}, userID interface{}, sortParams interface{}, pageParams interface{}) *MockMemoRepository_FindAllByUserIDWithEdges_Call

FindAllByUserIDWithEdges is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • sortParams model.MemoSortParams
  • pageParams model.PaginationParams

func (*MockMemoRepository_Expecter) FindByID 

func (_e *MockMemoRepository_Expecter) FindByID(ctx interface{}, memoID interface{}) *MockMemoRepository_FindByID_Call

FindByID is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockMemoRepository_Expecter) FindByIDWithEdges 

func (_e *MockMemoRepository_Expecter) FindByIDWithEdges(ctx interface{}, memoID interface{}) *MockMemoRepository_FindByIDWithEdges_Call

FindByIDWithEdges is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockMemoRepository_Expecter) RegisterSubscriber 

func (_e *MockMemoRepository_Expecter) RegisterSubscriber(ctx interface{}, memoID interface{}, userID interface{}) *MockMemoRepository_RegisterSubscriber_Call

RegisterSubscriber is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • userID uuid.UUID

func (*MockMemoRepository_Expecter) ReplaceTags 

func (_e *MockMemoRepository_Expecter) ReplaceTags(ctx interface{}, memoID interface{}, tagIDs interface{}, updateTime interface{}) *MockMemoRepository_ReplaceTags_Call

ReplaceTags is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • tagIDs []int
  • updateTime bool

func (*MockMemoRepository_Expecter) UnregisterSubscriber 

func (_e *MockMemoRepository_Expecter) UnregisterSubscriber(ctx interface{}, memoID interface{}, userID interface{}) *MockMemoRepository_UnregisterSubscriber_Call

UnregisterSubscriber is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • userID uuid.UUID

func (*MockMemoRepository_Expecter) Update 

func (_e *MockMemoRepository_Expecter) Update(_a0 interface{}, _a1 interface{}) *MockMemoRepository_Update_Call

Update is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *ent.Memo

func (*MockMemoRepository_Expecter) UpdateIsPublish 

func (_e *MockMemoRepository_Expecter) UpdateIsPublish(ctx interface{}, memoID interface{}, isPublish interface{}) *MockMemoRepository_UpdateIsPublish_Call

UpdateIsPublish is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • isPublish bool

type MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call 

type MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call struct {
	*mock.Call
}

MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllByUserIDAndTagNamesWithEdges'

func (*MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call) Return 

func (_c *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call) Return(_a0 []*ent.Memo, _a1 error) *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call

func (*MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call) Run 

func (_c *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call) Run(run func(ctx context.Context, userID uuid.UUID, tags []string, sortParams model.MemoSortParams, pageParams model.PaginationParams)) *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call

func (*MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call) RunAndReturn 

func (_c *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call) RunAndReturn(run func(context.Context, uuid.UUID, []string, model.MemoSortParams, model.PaginationParams) ([]*ent.Memo, error)) *MockMemoRepository_FindAllByUserIDAndTagNamesWithEdges_Call

type MockMemoRepository_FindAllByUserIDWithEdges_Call 

type MockMemoRepository_FindAllByUserIDWithEdges_Call struct {
	*mock.Call
}

MockMemoRepository_FindAllByUserIDWithEdges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllByUserIDWithEdges'

func (*MockMemoRepository_FindAllByUserIDWithEdges_Call) Return 

func (_c *MockMemoRepository_FindAllByUserIDWithEdges_Call) Return(_a0 []*ent.Memo, _a1 error) *MockMemoRepository_FindAllByUserIDWithEdges_Call

func (*MockMemoRepository_FindAllByUserIDWithEdges_Call) Run 

func (_c *MockMemoRepository_FindAllByUserIDWithEdges_Call) Run(run func(ctx context.Context, userID uuid.UUID, sortParams model.MemoSortParams, pageParams model.PaginationParams)) *MockMemoRepository_FindAllByUserIDWithEdges_Call

func (*MockMemoRepository_FindAllByUserIDWithEdges_Call) RunAndReturn 

func (_c *MockMemoRepository_FindAllByUserIDWithEdges_Call) RunAndReturn(run func(context.Context, uuid.UUID, model.MemoSortParams, model.PaginationParams) ([]*ent.Memo, error)) *MockMemoRepository_FindAllByUserIDWithEdges_Call

type MockMemoRepository_FindByIDWithEdges_Call 

type MockMemoRepository_FindByIDWithEdges_Call struct {
	*mock.Call
}

MockMemoRepository_FindByIDWithEdges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByIDWithEdges'

func (*MockMemoRepository_FindByIDWithEdges_Call) Return 

func (_c *MockMemoRepository_FindByIDWithEdges_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoRepository_FindByIDWithEdges_Call

func (*MockMemoRepository_FindByIDWithEdges_Call) Run 

func (_c *MockMemoRepository_FindByIDWithEdges_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockMemoRepository_FindByIDWithEdges_Call

func (*MockMemoRepository_FindByIDWithEdges_Call) RunAndReturn 

func (_c *MockMemoRepository_FindByIDWithEdges_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*ent.Memo, error)) *MockMemoRepository_FindByIDWithEdges_Call

type MockMemoRepository_FindByID_Call 

type MockMemoRepository_FindByID_Call struct {
	*mock.Call
}

MockMemoRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockMemoRepository_FindByID_Call) Return 

func (_c *MockMemoRepository_FindByID_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoRepository_FindByID_Call

func (*MockMemoRepository_FindByID_Call) Run 

func (_c *MockMemoRepository_FindByID_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockMemoRepository_FindByID_Call

func (*MockMemoRepository_FindByID_Call) RunAndReturn 

func (_c *MockMemoRepository_FindByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*ent.Memo, error)) *MockMemoRepository_FindByID_Call

type MockMemoRepository_RegisterSubscriber_Call 

type MockMemoRepository_RegisterSubscriber_Call struct {
	*mock.Call
}

MockMemoRepository_RegisterSubscriber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterSubscriber'

func (*MockMemoRepository_RegisterSubscriber_Call) Return 

func (_c *MockMemoRepository_RegisterSubscriber_Call) Return(_a0 error) *MockMemoRepository_RegisterSubscriber_Call

func (*MockMemoRepository_RegisterSubscriber_Call) Run 

func (_c *MockMemoRepository_RegisterSubscriber_Call) Run(run func(ctx context.Context, memoID uuid.UUID, userID uuid.UUID)) *MockMemoRepository_RegisterSubscriber_Call

func (*MockMemoRepository_RegisterSubscriber_Call) RunAndReturn 

func (_c *MockMemoRepository_RegisterSubscriber_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID) error) *MockMemoRepository_RegisterSubscriber_Call

type MockMemoRepository_ReplaceTags_Call 

type MockMemoRepository_ReplaceTags_Call struct {
	*mock.Call
}

MockMemoRepository_ReplaceTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceTags'

func (*MockMemoRepository_ReplaceTags_Call) Return 

func (_c *MockMemoRepository_ReplaceTags_Call) Return(_a0 error) *MockMemoRepository_ReplaceTags_Call

func (*MockMemoRepository_ReplaceTags_Call) Run 

func (_c *MockMemoRepository_ReplaceTags_Call) Run(run func(ctx context.Context, memoID uuid.UUID, tagIDs []int, updateTime bool)) *MockMemoRepository_ReplaceTags_Call

func (*MockMemoRepository_ReplaceTags_Call) RunAndReturn 

func (_c *MockMemoRepository_ReplaceTags_Call) RunAndReturn(run func(context.Context, uuid.UUID, []int, bool) error) *MockMemoRepository_ReplaceTags_Call

type MockMemoRepository_UnregisterSubscriber_Call 

type MockMemoRepository_UnregisterSubscriber_Call struct {
	*mock.Call
}

MockMemoRepository_UnregisterSubscriber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnregisterSubscriber'

func (*MockMemoRepository_UnregisterSubscriber_Call) Return 

func (_c *MockMemoRepository_UnregisterSubscriber_Call) Return(_a0 error) *MockMemoRepository_UnregisterSubscriber_Call

func (*MockMemoRepository_UnregisterSubscriber_Call) Run 

func (_c *MockMemoRepository_UnregisterSubscriber_Call) Run(run func(ctx context.Context, memoID uuid.UUID, userID uuid.UUID)) *MockMemoRepository_UnregisterSubscriber_Call

func (*MockMemoRepository_UnregisterSubscriber_Call) RunAndReturn 

func (_c *MockMemoRepository_UnregisterSubscriber_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID) error) *MockMemoRepository_UnregisterSubscriber_Call

type MockMemoRepository_UpdateIsPublish_Call 

type MockMemoRepository_UpdateIsPublish_Call struct {
	*mock.Call
}

MockMemoRepository_UpdateIsPublish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateIsPublish'

func (*MockMemoRepository_UpdateIsPublish_Call) Return 

func (_c *MockMemoRepository_UpdateIsPublish_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoRepository_UpdateIsPublish_Call

func (*MockMemoRepository_UpdateIsPublish_Call) Run 

func (_c *MockMemoRepository_UpdateIsPublish_Call) Run(run func(ctx context.Context, memoID uuid.UUID, isPublish bool)) *MockMemoRepository_UpdateIsPublish_Call

func (*MockMemoRepository_UpdateIsPublish_Call) RunAndReturn 

func (_c *MockMemoRepository_UpdateIsPublish_Call) RunAndReturn(run func(context.Context, uuid.UUID, bool) (*ent.Memo, error)) *MockMemoRepository_UpdateIsPublish_Call

type MockMemoRepository_Update_Call 

type MockMemoRepository_Update_Call struct {
	*mock.Call
}

MockMemoRepository_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockMemoRepository_Update_Call) Return 

func (_c *MockMemoRepository_Update_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoRepository_Update_Call

func (*MockMemoRepository_Update_Call) Run 

func (_c *MockMemoRepository_Update_Call) Run(run func(_a0 context.Context, _a1 *ent.Memo)) *MockMemoRepository_Update_Call

func (*MockMemoRepository_Update_Call) RunAndReturn 

func (_c *MockMemoRepository_Update_Call) RunAndReturn(run func(context.Context, *ent.Memo) (*ent.Memo, error)) *MockMemoRepository_Update_Call

type MockMemoService 

type MockMemoService struct {
	mock.Mock
}

MockMemoService is an autogenerated mock type for the MemoService type

func NewMockMemoService 

func NewMockMemoService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMemoService

NewMockMemoService creates a new instance of MockMemoService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMemoService) AuthorizeCollaborator 

func (_m *MockMemoService) AuthorizeCollaborator(ctx context.Context, memoID uuid.UUID, collaboratorID uuid.UUID, approve bool, requester *model.AppIDToken) error

AuthorizeCollaborator provides a mock function with given fields: ctx, memoID, collaboratorID, approve, requester

func (*MockMemoService) CreateMemo 

func (_m *MockMemoService) CreateMemo(ctx context.Context, memo *ent.Memo, tagNames []string, userID uuid.UUID) (*ent.Memo, error)

CreateMemo provides a mock function with given fields: ctx, memo, tagNames, userID

func (*MockMemoService) DeleteCollaborator 

func (_m *MockMemoService) DeleteCollaborator(ctx context.Context, memoID uuid.UUID, collaboratorID uuid.UUID, requester *model.AppIDToken) error

DeleteCollaborator provides a mock function with given fields: ctx, memoID, collaboratorID, requester

func (*MockMemoService) DeleteMemo 

func (_m *MockMemoService) DeleteMemo(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) error

DeleteMemo provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) DeleteOrphanTags 

func (_m *MockMemoService) DeleteOrphanTags(_a0 context.Context) (int, error)

DeleteOrphanTags provides a mock function with given fields: _a0

func (*MockMemoService) EXPECT 

func (_m *MockMemoService) EXPECT() *MockMemoService_Expecter

func (*MockMemoService) GetMemo 

func (_m *MockMemoService) GetMemo(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) (*ent.Memo, error)

GetMemo provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) ListCollaborators 

func (_m *MockMemoService) ListCollaborators(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) (*model.ListCollaboratorsResponse, error)

ListCollaborators provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) ListMemos 

func (_m *MockMemoService) ListMemos(ctx context.Context, userID uuid.UUID, tags []string, sortParams model.MemoSortParams, pageParams model.PaginationParams) ([]*ent.Memo, int, error)

ListMemos provides a mock function with given fields: ctx, userID, tags, sortParams, pageParams

func (*MockMemoService) ListSubscribers 

func (_m *MockMemoService) ListSubscribers(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) (*model.ListSubscribersResponse, error)

ListSubscribers provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) ListTags 

func (_m *MockMemoService) ListTags(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) ([]*ent.Tag, error)

ListTags provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) RegisterCollaborator 

func (_m *MockMemoService) RegisterCollaborator(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) error

RegisterCollaborator provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) ReplaceTags 

func (_m *MockMemoService) ReplaceTags(ctx context.Context, memoID uuid.UUID, tagNames []string, requester *model.AppIDToken) ([]*ent.Tag, error)

ReplaceTags provides a mock function with given fields: ctx, memoID, tagNames, requester

func (*MockMemoService) SearchTags 

func (_m *MockMemoService) SearchTags(ctx context.Context, keyword string, requester *model.AppIDToken) ([]*ent.Tag, error)

SearchTags provides a mock function with given fields: ctx, keyword, requester

func (*MockMemoService) SubscribeMemo 

func (_m *MockMemoService) SubscribeMemo(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) error

SubscribeMemo provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) UnsubscribeMemo 

func (_m *MockMemoService) UnsubscribeMemo(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken) error

UnsubscribeMemo provides a mock function with given fields: ctx, memoID, requester

func (*MockMemoService) UpdateMemo 

func (_m *MockMemoService) UpdateMemo(ctx context.Context, memo *ent.Memo, tagNames []string, requester *model.AppIDToken, isPinUpdateTime bool) (*ent.Memo, error)

UpdateMemo provides a mock function with given fields: ctx, memo, tagNames, requester, isPinUpdateTime

func (*MockMemoService) UpdateMemoPublishedState 

func (_m *MockMemoService) UpdateMemoPublishedState(ctx context.Context, memoID uuid.UUID, publish bool, requester *model.AppIDToken) (*ent.Memo, error)

UpdateMemoPublishedState provides a mock function with given fields: ctx, memoID, publish, requester

type MockMemoService_AuthorizeCollaborator_Call 

type MockMemoService_AuthorizeCollaborator_Call struct {
	*mock.Call
}

MockMemoService_AuthorizeCollaborator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeCollaborator'

func (*MockMemoService_AuthorizeCollaborator_Call) Return 

func (_c *MockMemoService_AuthorizeCollaborator_Call) Return(_a0 error) *MockMemoService_AuthorizeCollaborator_Call

func (*MockMemoService_AuthorizeCollaborator_Call) Run 

func (_c *MockMemoService_AuthorizeCollaborator_Call) Run(run func(ctx context.Context, memoID uuid.UUID, collaboratorID uuid.UUID, approve bool, requester *model.AppIDToken)) *MockMemoService_AuthorizeCollaborator_Call

func (*MockMemoService_AuthorizeCollaborator_Call) RunAndReturn 

func (_c *MockMemoService_AuthorizeCollaborator_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID, bool, *model.AppIDToken) error) *MockMemoService_AuthorizeCollaborator_Call

type MockMemoService_CreateMemo_Call 

type MockMemoService_CreateMemo_Call struct {
	*mock.Call
}

MockMemoService_CreateMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMemo'

func (*MockMemoService_CreateMemo_Call) Return 

func (_c *MockMemoService_CreateMemo_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoService_CreateMemo_Call

func (*MockMemoService_CreateMemo_Call) Run 

func (_c *MockMemoService_CreateMemo_Call) Run(run func(ctx context.Context, memo *ent.Memo, tagNames []string, userID uuid.UUID)) *MockMemoService_CreateMemo_Call

func (*MockMemoService_CreateMemo_Call) RunAndReturn 

func (_c *MockMemoService_CreateMemo_Call) RunAndReturn(run func(context.Context, *ent.Memo, []string, uuid.UUID) (*ent.Memo, error)) *MockMemoService_CreateMemo_Call

type MockMemoService_DeleteCollaborator_Call 

type MockMemoService_DeleteCollaborator_Call struct {
	*mock.Call
}

MockMemoService_DeleteCollaborator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCollaborator'

func (*MockMemoService_DeleteCollaborator_Call) Return 

func (_c *MockMemoService_DeleteCollaborator_Call) Return(_a0 error) *MockMemoService_DeleteCollaborator_Call

func (*MockMemoService_DeleteCollaborator_Call) Run 

func (_c *MockMemoService_DeleteCollaborator_Call) Run(run func(ctx context.Context, memoID uuid.UUID, collaboratorID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_DeleteCollaborator_Call

func (*MockMemoService_DeleteCollaborator_Call) RunAndReturn 

func (_c *MockMemoService_DeleteCollaborator_Call) RunAndReturn(run func(context.Context, uuid.UUID, uuid.UUID, *model.AppIDToken) error) *MockMemoService_DeleteCollaborator_Call

type MockMemoService_DeleteMemo_Call 

type MockMemoService_DeleteMemo_Call struct {
	*mock.Call
}

MockMemoService_DeleteMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMemo'

func (*MockMemoService_DeleteMemo_Call) Return 

func (_c *MockMemoService_DeleteMemo_Call) Return(_a0 error) *MockMemoService_DeleteMemo_Call

func (*MockMemoService_DeleteMemo_Call) Run 

func (_c *MockMemoService_DeleteMemo_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_DeleteMemo_Call

func (*MockMemoService_DeleteMemo_Call) RunAndReturn 

func (_c *MockMemoService_DeleteMemo_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) error) *MockMemoService_DeleteMemo_Call

type MockMemoService_DeleteOrphanTags_Call 

type MockMemoService_DeleteOrphanTags_Call struct {
	*mock.Call
}

MockMemoService_DeleteOrphanTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrphanTags'

func (*MockMemoService_DeleteOrphanTags_Call) Return 

func (_c *MockMemoService_DeleteOrphanTags_Call) Return(count int, err error) *MockMemoService_DeleteOrphanTags_Call

func (*MockMemoService_DeleteOrphanTags_Call) Run 

func (_c *MockMemoService_DeleteOrphanTags_Call) Run(run func(_a0 context.Context)) *MockMemoService_DeleteOrphanTags_Call

func (*MockMemoService_DeleteOrphanTags_Call) RunAndReturn 

func (_c *MockMemoService_DeleteOrphanTags_Call) RunAndReturn(run func(context.Context) (int, error)) *MockMemoService_DeleteOrphanTags_Call

type MockMemoService_Expecter 

type MockMemoService_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMemoService_Expecter) AuthorizeCollaborator 

func (_e *MockMemoService_Expecter) AuthorizeCollaborator(ctx interface{}, memoID interface{}, collaboratorID interface{}, approve interface{}, requester interface{}) *MockMemoService_AuthorizeCollaborator_Call

AuthorizeCollaborator is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • collaboratorID uuid.UUID
  • approve bool
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) CreateMemo 

func (_e *MockMemoService_Expecter) CreateMemo(ctx interface{}, memo interface{}, tagNames interface{}, userID interface{}) *MockMemoService_CreateMemo_Call

CreateMemo is a helper method to define mock.On call

  • ctx context.Context
  • memo *ent.Memo
  • tagNames []string
  • userID uuid.UUID

func (*MockMemoService_Expecter) DeleteCollaborator 

func (_e *MockMemoService_Expecter) DeleteCollaborator(ctx interface{}, memoID interface{}, collaboratorID interface{}, requester interface{}) *MockMemoService_DeleteCollaborator_Call

DeleteCollaborator is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • collaboratorID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) DeleteMemo 

func (_e *MockMemoService_Expecter) DeleteMemo(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_DeleteMemo_Call

DeleteMemo is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) DeleteOrphanTags 

func (_e *MockMemoService_Expecter) DeleteOrphanTags(_a0 interface{}) *MockMemoService_DeleteOrphanTags_Call

DeleteOrphanTags is a helper method to define mock.On call

  • _a0 context.Context

func (*MockMemoService_Expecter) GetMemo 

func (_e *MockMemoService_Expecter) GetMemo(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_GetMemo_Call

GetMemo is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) ListCollaborators 

func (_e *MockMemoService_Expecter) ListCollaborators(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_ListCollaborators_Call

ListCollaborators is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) ListMemos 

func (_e *MockMemoService_Expecter) ListMemos(ctx interface{}, userID interface{}, tags interface{}, sortParams interface{}, pageParams interface{}) *MockMemoService_ListMemos_Call

ListMemos is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • tags []string
  • sortParams model.MemoSortParams
  • pageParams model.PaginationParams

func (*MockMemoService_Expecter) ListSubscribers 

func (_e *MockMemoService_Expecter) ListSubscribers(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_ListSubscribers_Call

ListSubscribers is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) ListTags 

func (_e *MockMemoService_Expecter) ListTags(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_ListTags_Call

ListTags is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) RegisterCollaborator 

func (_e *MockMemoService_Expecter) RegisterCollaborator(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_RegisterCollaborator_Call

RegisterCollaborator is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) ReplaceTags 

func (_e *MockMemoService_Expecter) ReplaceTags(ctx interface{}, memoID interface{}, tagNames interface{}, requester interface{}) *MockMemoService_ReplaceTags_Call

ReplaceTags is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • tagNames []string
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) SearchTags 

func (_e *MockMemoService_Expecter) SearchTags(ctx interface{}, keyword interface{}, requester interface{}) *MockMemoService_SearchTags_Call

SearchTags is a helper method to define mock.On call

  • ctx context.Context
  • keyword string
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) SubscribeMemo 

func (_e *MockMemoService_Expecter) SubscribeMemo(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_SubscribeMemo_Call

SubscribeMemo is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) UnsubscribeMemo 

func (_e *MockMemoService_Expecter) UnsubscribeMemo(ctx interface{}, memoID interface{}, requester interface{}) *MockMemoService_UnsubscribeMemo_Call

UnsubscribeMemo is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • requester *model.AppIDToken

func (*MockMemoService_Expecter) UpdateMemo 

func (_e *MockMemoService_Expecter) UpdateMemo(ctx interface{}, memo interface{}, tagNames interface{}, requester interface{}, isPinUpdateTime interface{}) *MockMemoService_UpdateMemo_Call

UpdateMemo is a helper method to define mock.On call

  • ctx context.Context
  • memo *ent.Memo
  • tagNames []string
  • requester *model.AppIDToken
  • isPinUpdateTime bool

func (*MockMemoService_Expecter) UpdateMemoPublishedState 

func (_e *MockMemoService_Expecter) UpdateMemoPublishedState(ctx interface{}, memoID interface{}, publish interface{}, requester interface{}) *MockMemoService_UpdateMemoPublishedState_Call

UpdateMemoPublishedState is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID
  • publish bool
  • requester *model.AppIDToken

type MockMemoService_GetMemo_Call 

type MockMemoService_GetMemo_Call struct {
	*mock.Call
}

MockMemoService_GetMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMemo'

func (*MockMemoService_GetMemo_Call) Return 

func (_c *MockMemoService_GetMemo_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoService_GetMemo_Call

func (*MockMemoService_GetMemo_Call) Run 

func (_c *MockMemoService_GetMemo_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_GetMemo_Call

func (*MockMemoService_GetMemo_Call) RunAndReturn 

func (_c *MockMemoService_GetMemo_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) (*ent.Memo, error)) *MockMemoService_GetMemo_Call

type MockMemoService_ListCollaborators_Call 

type MockMemoService_ListCollaborators_Call struct {
	*mock.Call
}

MockMemoService_ListCollaborators_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCollaborators'

func (*MockMemoService_ListCollaborators_Call) Return 

func (_c *MockMemoService_ListCollaborators_Call) Return(_a0 *model.ListCollaboratorsResponse, _a1 error) *MockMemoService_ListCollaborators_Call

func (*MockMemoService_ListCollaborators_Call) Run 

func (_c *MockMemoService_ListCollaborators_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_ListCollaborators_Call

func (*MockMemoService_ListCollaborators_Call) RunAndReturn 

func (_c *MockMemoService_ListCollaborators_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) (*model.ListCollaboratorsResponse, error)) *MockMemoService_ListCollaborators_Call

type MockMemoService_ListMemos_Call 

type MockMemoService_ListMemos_Call struct {
	*mock.Call
}

MockMemoService_ListMemos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMemos'

func (*MockMemoService_ListMemos_Call) Return 

func (_c *MockMemoService_ListMemos_Call) Return(memos []*ent.Memo, totalCount int, err error) *MockMemoService_ListMemos_Call

func (*MockMemoService_ListMemos_Call) Run 

func (_c *MockMemoService_ListMemos_Call) Run(run func(ctx context.Context, userID uuid.UUID, tags []string, sortParams model.MemoSortParams, pageParams model.PaginationParams)) *MockMemoService_ListMemos_Call

func (*MockMemoService_ListMemos_Call) RunAndReturn 

func (_c *MockMemoService_ListMemos_Call) RunAndReturn(run func(context.Context, uuid.UUID, []string, model.MemoSortParams, model.PaginationParams) ([]*ent.Memo, int, error)) *MockMemoService_ListMemos_Call

type MockMemoService_ListSubscribers_Call 

type MockMemoService_ListSubscribers_Call struct {
	*mock.Call
}

MockMemoService_ListSubscribers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSubscribers'

func (*MockMemoService_ListSubscribers_Call) Return 

func (_c *MockMemoService_ListSubscribers_Call) Return(_a0 *model.ListSubscribersResponse, _a1 error) *MockMemoService_ListSubscribers_Call

func (*MockMemoService_ListSubscribers_Call) Run 

func (_c *MockMemoService_ListSubscribers_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_ListSubscribers_Call

func (*MockMemoService_ListSubscribers_Call) RunAndReturn 

func (_c *MockMemoService_ListSubscribers_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) (*model.ListSubscribersResponse, error)) *MockMemoService_ListSubscribers_Call

type MockMemoService_ListTags_Call 

type MockMemoService_ListTags_Call struct {
	*mock.Call
}

MockMemoService_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'

func (*MockMemoService_ListTags_Call) Return 

func (_c *MockMemoService_ListTags_Call) Return(_a0 []*ent.Tag, _a1 error) *MockMemoService_ListTags_Call

func (*MockMemoService_ListTags_Call) Run 

func (_c *MockMemoService_ListTags_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_ListTags_Call

func (*MockMemoService_ListTags_Call) RunAndReturn 

func (_c *MockMemoService_ListTags_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) ([]*ent.Tag, error)) *MockMemoService_ListTags_Call

type MockMemoService_RegisterCollaborator_Call 

type MockMemoService_RegisterCollaborator_Call struct {
	*mock.Call
}

MockMemoService_RegisterCollaborator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterCollaborator'

func (*MockMemoService_RegisterCollaborator_Call) Return 

func (_c *MockMemoService_RegisterCollaborator_Call) Return(_a0 error) *MockMemoService_RegisterCollaborator_Call

func (*MockMemoService_RegisterCollaborator_Call) Run 

func (_c *MockMemoService_RegisterCollaborator_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_RegisterCollaborator_Call

func (*MockMemoService_RegisterCollaborator_Call) RunAndReturn 

func (_c *MockMemoService_RegisterCollaborator_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) error) *MockMemoService_RegisterCollaborator_Call

type MockMemoService_ReplaceTags_Call 

type MockMemoService_ReplaceTags_Call struct {
	*mock.Call
}

MockMemoService_ReplaceTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceTags'

func (*MockMemoService_ReplaceTags_Call) Return 

func (_c *MockMemoService_ReplaceTags_Call) Return(_a0 []*ent.Tag, _a1 error) *MockMemoService_ReplaceTags_Call

func (*MockMemoService_ReplaceTags_Call) Run 

func (_c *MockMemoService_ReplaceTags_Call) Run(run func(ctx context.Context, memoID uuid.UUID, tagNames []string, requester *model.AppIDToken)) *MockMemoService_ReplaceTags_Call

func (*MockMemoService_ReplaceTags_Call) RunAndReturn 

func (_c *MockMemoService_ReplaceTags_Call) RunAndReturn(run func(context.Context, uuid.UUID, []string, *model.AppIDToken) ([]*ent.Tag, error)) *MockMemoService_ReplaceTags_Call

type MockMemoService_SearchTags_Call 

type MockMemoService_SearchTags_Call struct {
	*mock.Call
}

MockMemoService_SearchTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchTags'

func (*MockMemoService_SearchTags_Call) Return 

func (_c *MockMemoService_SearchTags_Call) Return(_a0 []*ent.Tag, _a1 error) *MockMemoService_SearchTags_Call

func (*MockMemoService_SearchTags_Call) Run 

func (_c *MockMemoService_SearchTags_Call) Run(run func(ctx context.Context, keyword string, requester *model.AppIDToken)) *MockMemoService_SearchTags_Call

func (*MockMemoService_SearchTags_Call) RunAndReturn 

func (_c *MockMemoService_SearchTags_Call) RunAndReturn(run func(context.Context, string, *model.AppIDToken) ([]*ent.Tag, error)) *MockMemoService_SearchTags_Call

type MockMemoService_SubscribeMemo_Call 

type MockMemoService_SubscribeMemo_Call struct {
	*mock.Call
}

MockMemoService_SubscribeMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeMemo'

func (*MockMemoService_SubscribeMemo_Call) Return 

func (_c *MockMemoService_SubscribeMemo_Call) Return(_a0 error) *MockMemoService_SubscribeMemo_Call

func (*MockMemoService_SubscribeMemo_Call) Run 

func (_c *MockMemoService_SubscribeMemo_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_SubscribeMemo_Call

func (*MockMemoService_SubscribeMemo_Call) RunAndReturn 

func (_c *MockMemoService_SubscribeMemo_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) error) *MockMemoService_SubscribeMemo_Call

type MockMemoService_UnsubscribeMemo_Call 

type MockMemoService_UnsubscribeMemo_Call struct {
	*mock.Call
}

MockMemoService_UnsubscribeMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsubscribeMemo'

func (*MockMemoService_UnsubscribeMemo_Call) Return 

func (_c *MockMemoService_UnsubscribeMemo_Call) Return(_a0 error) *MockMemoService_UnsubscribeMemo_Call

func (*MockMemoService_UnsubscribeMemo_Call) Run 

func (_c *MockMemoService_UnsubscribeMemo_Call) Run(run func(ctx context.Context, memoID uuid.UUID, requester *model.AppIDToken)) *MockMemoService_UnsubscribeMemo_Call

func (*MockMemoService_UnsubscribeMemo_Call) RunAndReturn 

func (_c *MockMemoService_UnsubscribeMemo_Call) RunAndReturn(run func(context.Context, uuid.UUID, *model.AppIDToken) error) *MockMemoService_UnsubscribeMemo_Call

type MockMemoService_UpdateMemoPublishedState_Call 

type MockMemoService_UpdateMemoPublishedState_Call struct {
	*mock.Call
}

MockMemoService_UpdateMemoPublishedState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMemoPublishedState'

func (*MockMemoService_UpdateMemoPublishedState_Call) Return 

func (_c *MockMemoService_UpdateMemoPublishedState_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoService_UpdateMemoPublishedState_Call

func (*MockMemoService_UpdateMemoPublishedState_Call) Run 

func (_c *MockMemoService_UpdateMemoPublishedState_Call) Run(run func(ctx context.Context, memoID uuid.UUID, publish bool, requester *model.AppIDToken)) *MockMemoService_UpdateMemoPublishedState_Call

func (*MockMemoService_UpdateMemoPublishedState_Call) RunAndReturn 

func (_c *MockMemoService_UpdateMemoPublishedState_Call) RunAndReturn(run func(context.Context, uuid.UUID, bool, *model.AppIDToken) (*ent.Memo, error)) *MockMemoService_UpdateMemoPublishedState_Call

type MockMemoService_UpdateMemo_Call 

type MockMemoService_UpdateMemo_Call struct {
	*mock.Call
}

MockMemoService_UpdateMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMemo'

func (*MockMemoService_UpdateMemo_Call) Return 

func (_c *MockMemoService_UpdateMemo_Call) Return(_a0 *ent.Memo, _a1 error) *MockMemoService_UpdateMemo_Call

func (*MockMemoService_UpdateMemo_Call) Run 

func (_c *MockMemoService_UpdateMemo_Call) Run(run func(ctx context.Context, memo *ent.Memo, tagNames []string, requester *model.AppIDToken, isPinUpdateTime bool)) *MockMemoService_UpdateMemo_Call

func (*MockMemoService_UpdateMemo_Call) RunAndReturn 

func (_c *MockMemoService_UpdateMemo_Call) RunAndReturn(run func(context.Context, *ent.Memo, []string, *model.AppIDToken, bool) (*ent.Memo, error)) *MockMemoService_UpdateMemo_Call

type MockPinger 

type MockPinger struct {
	mock.Mock
}

MockPinger is an autogenerated mock type for the Pinger type

func NewMockPinger 

func NewMockPinger(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPinger

NewMockPinger creates a new instance of MockPinger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPinger) EXPECT 

func (_m *MockPinger) EXPECT() *MockPinger_Expecter

func (*MockPinger) Name 

func (_m *MockPinger) Name() string

Name provides a mock function with given fields:

func (*MockPinger) Ping 

func (_m *MockPinger) Ping(_a0 context.Context) error

Ping provides a mock function with given fields: _a0

type MockPinger_Expecter 

type MockPinger_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockPinger_Expecter) Name 

func (_e *MockPinger_Expecter) Name() *MockPinger_Name_Call

Name is a helper method to define mock.On call

func (*MockPinger_Expecter) Ping 

func (_e *MockPinger_Expecter) Ping(_a0 interface{}) *MockPinger_Ping_Call

Ping is a helper method to define mock.On call

  • _a0 context.Context

type MockPinger_Name_Call 

type MockPinger_Name_Call struct {
	*mock.Call
}

MockPinger_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'

func (*MockPinger_Name_Call) Return 

func (_c *MockPinger_Name_Call) Return(_a0 string) *MockPinger_Name_Call

func (*MockPinger_Name_Call) Run 

func (_c *MockPinger_Name_Call) Run(run func()) *MockPinger_Name_Call

func (*MockPinger_Name_Call) RunAndReturn 

func (_c *MockPinger_Name_Call) RunAndReturn(run func() string) *MockPinger_Name_Call

type MockPinger_Ping_Call 

type MockPinger_Ping_Call struct {
	*mock.Call
}

MockPinger_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping'

func (*MockPinger_Ping_Call) Return 

func (_c *MockPinger_Ping_Call) Return(_a0 error) *MockPinger_Ping_Call

func (*MockPinger_Ping_Call) Run 

func (_c *MockPinger_Ping_Call) Run(run func(_a0 context.Context)) *MockPinger_Ping_Call

func (*MockPinger_Ping_Call) RunAndReturn 

func (_c *MockPinger_Ping_Call) RunAndReturn(run func(context.Context) error) *MockPinger_Ping_Call

type MockTagRepository 

type MockTagRepository struct {
	mock.Mock
}

MockTagRepository is an autogenerated mock type for the TagRepository type

func NewMockTagRepository 

func NewMockTagRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTagRepository

NewMockTagRepository creates a new instance of MockTagRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockTagRepository) CreateIfNotExist 

func (_m *MockTagRepository) CreateIfNotExist(ctx context.Context, tagName string) (*ent.Tag, error)

CreateIfNotExist provides a mock function with given fields: ctx, tagName

func (*MockTagRepository) DeleteAllWithoutMemo 

func (_m *MockTagRepository) DeleteAllWithoutMemo(ctx context.Context, excludes []string) (int, error)

DeleteAllWithoutMemo provides a mock function with given fields: ctx, excludes

func (*MockTagRepository) EXPECT 

func (_m *MockTagRepository) EXPECT() *MockTagRepository_Expecter

func (*MockTagRepository) FindAllByMemoID 

func (_m *MockTagRepository) FindAllByMemoID(ctx context.Context, memoID uuid.UUID) ([]*ent.Tag, error)

FindAllByMemoID provides a mock function with given fields: ctx, memoID

func (*MockTagRepository) FindAllByUserIDAndNameContains 

func (_m *MockTagRepository) FindAllByUserIDAndNameContains(ctx context.Context, userID uuid.UUID, name string) ([]*ent.Tag, error)

FindAllByUserIDAndNameContains provides a mock function with given fields: ctx, userID, name

type MockTagRepository_CreateIfNotExist_Call 

type MockTagRepository_CreateIfNotExist_Call struct {
	*mock.Call
}

MockTagRepository_CreateIfNotExist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIfNotExist'

func (*MockTagRepository_CreateIfNotExist_Call) Return 

func (_c *MockTagRepository_CreateIfNotExist_Call) Return(_a0 *ent.Tag, _a1 error) *MockTagRepository_CreateIfNotExist_Call

func (*MockTagRepository_CreateIfNotExist_Call) Run 

func (_c *MockTagRepository_CreateIfNotExist_Call) Run(run func(ctx context.Context, tagName string)) *MockTagRepository_CreateIfNotExist_Call

func (*MockTagRepository_CreateIfNotExist_Call) RunAndReturn 

func (_c *MockTagRepository_CreateIfNotExist_Call) RunAndReturn(run func(context.Context, string) (*ent.Tag, error)) *MockTagRepository_CreateIfNotExist_Call

type MockTagRepository_DeleteAllWithoutMemo_Call 

type MockTagRepository_DeleteAllWithoutMemo_Call struct {
	*mock.Call
}

MockTagRepository_DeleteAllWithoutMemo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllWithoutMemo'

func (*MockTagRepository_DeleteAllWithoutMemo_Call) Return 

func (_c *MockTagRepository_DeleteAllWithoutMemo_Call) Return(count int, err error) *MockTagRepository_DeleteAllWithoutMemo_Call

func (*MockTagRepository_DeleteAllWithoutMemo_Call) Run 

func (_c *MockTagRepository_DeleteAllWithoutMemo_Call) Run(run func(ctx context.Context, excludes []string)) *MockTagRepository_DeleteAllWithoutMemo_Call

func (*MockTagRepository_DeleteAllWithoutMemo_Call) RunAndReturn 

func (_c *MockTagRepository_DeleteAllWithoutMemo_Call) RunAndReturn(run func(context.Context, []string) (int, error)) *MockTagRepository_DeleteAllWithoutMemo_Call

type MockTagRepository_Expecter 

type MockTagRepository_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockTagRepository_Expecter) CreateIfNotExist 

func (_e *MockTagRepository_Expecter) CreateIfNotExist(ctx interface{}, tagName interface{}) *MockTagRepository_CreateIfNotExist_Call

CreateIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • tagName string

func (*MockTagRepository_Expecter) DeleteAllWithoutMemo 

func (_e *MockTagRepository_Expecter) DeleteAllWithoutMemo(ctx interface{}, excludes interface{}) *MockTagRepository_DeleteAllWithoutMemo_Call

DeleteAllWithoutMemo is a helper method to define mock.On call

  • ctx context.Context
  • excludes []string

func (*MockTagRepository_Expecter) FindAllByMemoID 

func (_e *MockTagRepository_Expecter) FindAllByMemoID(ctx interface{}, memoID interface{}) *MockTagRepository_FindAllByMemoID_Call

FindAllByMemoID is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockTagRepository_Expecter) FindAllByUserIDAndNameContains 

func (_e *MockTagRepository_Expecter) FindAllByUserIDAndNameContains(ctx interface{}, userID interface{}, name interface{}) *MockTagRepository_FindAllByUserIDAndNameContains_Call

FindAllByUserIDAndNameContains is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • name string

type MockTagRepository_FindAllByMemoID_Call 

type MockTagRepository_FindAllByMemoID_Call struct {
	*mock.Call
}

MockTagRepository_FindAllByMemoID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllByMemoID'

func (*MockTagRepository_FindAllByMemoID_Call) Return 

func (_c *MockTagRepository_FindAllByMemoID_Call) Return(_a0 []*ent.Tag, _a1 error) *MockTagRepository_FindAllByMemoID_Call

func (*MockTagRepository_FindAllByMemoID_Call) Run 

func (_c *MockTagRepository_FindAllByMemoID_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockTagRepository_FindAllByMemoID_Call

func (*MockTagRepository_FindAllByMemoID_Call) RunAndReturn 

func (_c *MockTagRepository_FindAllByMemoID_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*ent.Tag, error)) *MockTagRepository_FindAllByMemoID_Call

type MockTagRepository_FindAllByUserIDAndNameContains_Call 

type MockTagRepository_FindAllByUserIDAndNameContains_Call struct {
	*mock.Call
}

MockTagRepository_FindAllByUserIDAndNameContains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllByUserIDAndNameContains'

func (*MockTagRepository_FindAllByUserIDAndNameContains_Call) Return 

func (_c *MockTagRepository_FindAllByUserIDAndNameContains_Call) Return(_a0 []*ent.Tag, _a1 error) *MockTagRepository_FindAllByUserIDAndNameContains_Call

func (*MockTagRepository_FindAllByUserIDAndNameContains_Call) Run 

func (_c *MockTagRepository_FindAllByUserIDAndNameContains_Call) Run(run func(ctx context.Context, userID uuid.UUID, name string)) *MockTagRepository_FindAllByUserIDAndNameContains_Call

func (*MockTagRepository_FindAllByUserIDAndNameContains_Call) RunAndReturn 

func (_c *MockTagRepository_FindAllByUserIDAndNameContains_Call) RunAndReturn(run func(context.Context, uuid.UUID, string) ([]*ent.Tag, error)) *MockTagRepository_FindAllByUserIDAndNameContains_Call

type MockTransactionManager 

type MockTransactionManager struct {
	mock.Mock
}

MockTransactionManager is an autogenerated mock type for the TransactionManager type

func NewMockTransactionManager 

func NewMockTransactionManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTransactionManager

NewMockTransactionManager creates a new instance of MockTransactionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockTransactionManager) BeginTx 

func (_m *MockTransactionManager) BeginTx(_a0 context.Context) (context.Context, func() error, func() error)

BeginTx provides a mock function with given fields: _a0

func (*MockTransactionManager) EXPECT 

func (_m *MockTransactionManager) EXPECT() *MockTransactionManager_Expecter

func (*MockTransactionManager) WithTx 

func (_m *MockTransactionManager) WithTx(_a0 context.Context, _a1 func(context.Context) error) error

WithTx provides a mock function with given fields: _a0, _a1

type MockTransactionManager_BeginTx_Call 

type MockTransactionManager_BeginTx_Call struct {
	*mock.Call
}

MockTransactionManager_BeginTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BeginTx'

func (*MockTransactionManager_BeginTx_Call) Return 

func (_c *MockTransactionManager_BeginTx_Call) Return(ctxWithTx context.Context, commit func() error, rollback func() error) *MockTransactionManager_BeginTx_Call

func (*MockTransactionManager_BeginTx_Call) Run 

func (_c *MockTransactionManager_BeginTx_Call) Run(run func(_a0 context.Context)) *MockTransactionManager_BeginTx_Call

func (*MockTransactionManager_BeginTx_Call) RunAndReturn 

func (_c *MockTransactionManager_BeginTx_Call) RunAndReturn(run func(context.Context) (context.Context, func() error, func() error)) *MockTransactionManager_BeginTx_Call

type MockTransactionManager_Expecter 

type MockTransactionManager_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockTransactionManager_Expecter) BeginTx 

func (_e *MockTransactionManager_Expecter) BeginTx(_a0 interface{}) *MockTransactionManager_BeginTx_Call

BeginTx is a helper method to define mock.On call

  • _a0 context.Context

func (*MockTransactionManager_Expecter) WithTx 

func (_e *MockTransactionManager_Expecter) WithTx(_a0 interface{}, _a1 interface{}) *MockTransactionManager_WithTx_Call

WithTx is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 func(context.Context) error

type MockTransactionManager_WithTx_Call 

type MockTransactionManager_WithTx_Call struct {
	*mock.Call
}

MockTransactionManager_WithTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithTx'

func (*MockTransactionManager_WithTx_Call) Return 

func (_c *MockTransactionManager_WithTx_Call) Return(_a0 error) *MockTransactionManager_WithTx_Call

func (*MockTransactionManager_WithTx_Call) Run 

func (_c *MockTransactionManager_WithTx_Call) Run(run func(_a0 context.Context, _a1 func(context.Context) error)) *MockTransactionManager_WithTx_Call

func (*MockTransactionManager_WithTx_Call) RunAndReturn 

func (_c *MockTransactionManager_WithTx_Call) RunAndReturn(run func(context.Context, func(context.Context) error) error) *MockTransactionManager_WithTx_Call

type MockUserRepository 

type MockUserRepository struct {
	mock.Mock
}

MockUserRepository is an autogenerated mock type for the UserRepository type

func NewMockUserRepository 

func NewMockUserRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUserRepository

NewMockUserRepository creates a new instance of MockUserRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockUserRepository) EXPECT 

func (_m *MockUserRepository) EXPECT() *MockUserRepository_Expecter

func (*MockUserRepository) FindAllByCollaboratingMemoIDWithEdges 

func (_m *MockUserRepository) FindAllByCollaboratingMemoIDWithEdges(ctx context.Context, memoID uuid.UUID) ([]*ent.User, error)

FindAllByCollaboratingMemoIDWithEdges provides a mock function with given fields: ctx, memoID

func (*MockUserRepository) FindAllBySubscribingMemoID 

func (_m *MockUserRepository) FindAllBySubscribingMemoID(ctx context.Context, memoID uuid.UUID) ([]*ent.User, error)

FindAllBySubscribingMemoID provides a mock function with given fields: ctx, memoID

func (*MockUserRepository) FindByEmail 

func (_m *MockUserRepository) FindByEmail(ctx context.Context, email string) (*ent.User, error)

FindByEmail provides a mock function with given fields: ctx, email

func (*MockUserRepository) FindByID 

func (_m *MockUserRepository) FindByID(ctx context.Context, userID uuid.UUID) (*ent.User, error)

FindByID provides a mock function with given fields: ctx, userID

func (*MockUserRepository) Upsert 

func (_m *MockUserRepository) Upsert(_a0 context.Context, _a1 *ent.User) (*ent.User, error)

Upsert provides a mock function with given fields: _a0, _a1

type MockUserRepository_Expecter 

type MockUserRepository_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockUserRepository_Expecter) FindAllByCollaboratingMemoIDWithEdges 

func (_e *MockUserRepository_Expecter) FindAllByCollaboratingMemoIDWithEdges(ctx interface{}, memoID interface{}) *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call

FindAllByCollaboratingMemoIDWithEdges is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockUserRepository_Expecter) FindAllBySubscribingMemoID 

func (_e *MockUserRepository_Expecter) FindAllBySubscribingMemoID(ctx interface{}, memoID interface{}) *MockUserRepository_FindAllBySubscribingMemoID_Call

FindAllBySubscribingMemoID is a helper method to define mock.On call

  • ctx context.Context
  • memoID uuid.UUID

func (*MockUserRepository_Expecter) FindByEmail 

func (_e *MockUserRepository_Expecter) FindByEmail(ctx interface{}, email interface{}) *MockUserRepository_FindByEmail_Call

FindByEmail is a helper method to define mock.On call

  • ctx context.Context
  • email string

func (*MockUserRepository_Expecter) FindByID 

func (_e *MockUserRepository_Expecter) FindByID(ctx interface{}, userID interface{}) *MockUserRepository_FindByID_Call

FindByID is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockUserRepository_Expecter) Upsert 

func (_e *MockUserRepository_Expecter) Upsert(_a0 interface{}, _a1 interface{}) *MockUserRepository_Upsert_Call

Upsert is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *ent.User

type MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call 

type MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call struct {
	*mock.Call
}

MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllByCollaboratingMemoIDWithEdges'

func (*MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call) Return 

func (_c *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call) Return(_a0 []*ent.User, _a1 error) *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call

func (*MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call) Run 

func (_c *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call

func (*MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call) RunAndReturn 

func (_c *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*ent.User, error)) *MockUserRepository_FindAllByCollaboratingMemoIDWithEdges_Call

type MockUserRepository_FindAllBySubscribingMemoID_Call 

type MockUserRepository_FindAllBySubscribingMemoID_Call struct {
	*mock.Call
}

MockUserRepository_FindAllBySubscribingMemoID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAllBySubscribingMemoID'

func (*MockUserRepository_FindAllBySubscribingMemoID_Call) Return 

func (_c *MockUserRepository_FindAllBySubscribingMemoID_Call) Return(_a0 []*ent.User, _a1 error) *MockUserRepository_FindAllBySubscribingMemoID_Call

func (*MockUserRepository_FindAllBySubscribingMemoID_Call) Run 

func (_c *MockUserRepository_FindAllBySubscribingMemoID_Call) Run(run func(ctx context.Context, memoID uuid.UUID)) *MockUserRepository_FindAllBySubscribingMemoID_Call

func (*MockUserRepository_FindAllBySubscribingMemoID_Call) RunAndReturn 

func (_c *MockUserRepository_FindAllBySubscribingMemoID_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*ent.User, error)) *MockUserRepository_FindAllBySubscribingMemoID_Call

type MockUserRepository_FindByEmail_Call 

type MockUserRepository_FindByEmail_Call struct {
	*mock.Call
}

MockUserRepository_FindByEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByEmail'

func (*MockUserRepository_FindByEmail_Call) Return 

func (_c *MockUserRepository_FindByEmail_Call) Return(_a0 *ent.User, _a1 error) *MockUserRepository_FindByEmail_Call

func (*MockUserRepository_FindByEmail_Call) Run 

func (_c *MockUserRepository_FindByEmail_Call) Run(run func(ctx context.Context, email string)) *MockUserRepository_FindByEmail_Call

func (*MockUserRepository_FindByEmail_Call) RunAndReturn 

func (_c *MockUserRepository_FindByEmail_Call) RunAndReturn(run func(context.Context, string) (*ent.User, error)) *MockUserRepository_FindByEmail_Call

type MockUserRepository_FindByID_Call 

type MockUserRepository_FindByID_Call struct {
	*mock.Call
}

MockUserRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'

func (*MockUserRepository_FindByID_Call) Return 

func (_c *MockUserRepository_FindByID_Call) Return(_a0 *ent.User, _a1 error) *MockUserRepository_FindByID_Call

func (*MockUserRepository_FindByID_Call) Run 

func (_c *MockUserRepository_FindByID_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockUserRepository_FindByID_Call

func (*MockUserRepository_FindByID_Call) RunAndReturn 

func (_c *MockUserRepository_FindByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*ent.User, error)) *MockUserRepository_FindByID_Call

type MockUserRepository_Upsert_Call 

type MockUserRepository_Upsert_Call struct {
	*mock.Call
}

MockUserRepository_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'

func (*MockUserRepository_Upsert_Call) Return 

func (_c *MockUserRepository_Upsert_Call) Return(_a0 *ent.User, _a1 error) *MockUserRepository_Upsert_Call

func (*MockUserRepository_Upsert_Call) Run 

func (_c *MockUserRepository_Upsert_Call) Run(run func(_a0 context.Context, _a1 *ent.User)) *MockUserRepository_Upsert_Call

func (*MockUserRepository_Upsert_Call) RunAndReturn 

func (_c *MockUserRepository_Upsert_Call) RunAndReturn(run func(context.Context, *ent.User) (*ent.User, error)) *MockUserRepository_Upsert_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.