mocks

package
v0.6.0 Latest Latest
Warning

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

 Go to latest Published: Feb 19, 2026 License: MIT Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockDekRepository 

type MockDekRepository struct {
	mock.Mock
}

MockDekRepository is an autogenerated mock type for the DekRepository type

func NewMockDekRepository 

func NewMockDekRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockDekRepository

NewMockDekRepository creates a new instance of MockDekRepository. 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 (*MockDekRepository) Create 

func (_mock *MockDekRepository) Create(ctx context.Context, dek *domain.Dek) error

Create provides a mock function for the type MockDekRepository

func (*MockDekRepository) EXPECT 

func (_m *MockDekRepository) EXPECT() *MockDekRepository_Expecter

func (*MockDekRepository) Get 

func (_mock *MockDekRepository) Get(ctx context.Context, dekID uuid.UUID) (*domain.Dek, error)

Get provides a mock function for the type MockDekRepository

type MockDekRepository_Create_Call 

type MockDekRepository_Create_Call struct {
	*mock.Call
}

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

func (*MockDekRepository_Create_Call) Return 

func (_c *MockDekRepository_Create_Call) Return(err error) *MockDekRepository_Create_Call

func (*MockDekRepository_Create_Call) Run 

func (_c *MockDekRepository_Create_Call) Run(run func(ctx context.Context, dek *domain.Dek)) *MockDekRepository_Create_Call

func (*MockDekRepository_Create_Call) RunAndReturn 

func (_c *MockDekRepository_Create_Call) RunAndReturn(run func(ctx context.Context, dek *domain.Dek) error) *MockDekRepository_Create_Call

type MockDekRepository_Expecter 

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

func (*MockDekRepository_Expecter) Create 

func (_e *MockDekRepository_Expecter) Create(ctx interface{}, dek interface{}) *MockDekRepository_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • dek *domain.Dek

func (*MockDekRepository_Expecter) Get 

func (_e *MockDekRepository_Expecter) Get(ctx interface{}, dekID interface{}) *MockDekRepository_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • dekID uuid.UUID

type MockDekRepository_Get_Call 

type MockDekRepository_Get_Call struct {
	*mock.Call
}

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

func (*MockDekRepository_Get_Call) Return 

func (_c *MockDekRepository_Get_Call) Return(dek *domain.Dek, err error) *MockDekRepository_Get_Call

func (*MockDekRepository_Get_Call) Run 

func (_c *MockDekRepository_Get_Call) Run(run func(ctx context.Context, dekID uuid.UUID)) *MockDekRepository_Get_Call

func (*MockDekRepository_Get_Call) RunAndReturn 

func (_c *MockDekRepository_Get_Call) RunAndReturn(run func(ctx context.Context, dekID uuid.UUID) (*domain.Dek, error)) *MockDekRepository_Get_Call

type MockHashService 

type MockHashService struct {
	mock.Mock
}

MockHashService is an autogenerated mock type for the HashService type

func NewMockHashService 

func NewMockHashService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockHashService

NewMockHashService creates a new instance of MockHashService. 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 (*MockHashService) EXPECT 

func (_m *MockHashService) EXPECT() *MockHashService_Expecter

func (*MockHashService) Hash 

func (_mock *MockHashService) Hash(value []byte) string

Hash provides a mock function for the type MockHashService

type MockHashService_Expecter 

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

func (*MockHashService_Expecter) Hash 

func (_e *MockHashService_Expecter) Hash(value interface{}) *MockHashService_Hash_Call

Hash is a helper method to define mock.On call

  • value []byte

type MockHashService_Hash_Call 

type MockHashService_Hash_Call struct {
	*mock.Call
}

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

func (*MockHashService_Hash_Call) Return 

func (_c *MockHashService_Hash_Call) Return(s string) *MockHashService_Hash_Call

func (*MockHashService_Hash_Call) Run 

func (_c *MockHashService_Hash_Call) Run(run func(value []byte)) *MockHashService_Hash_Call

func (*MockHashService_Hash_Call) RunAndReturn 

func (_c *MockHashService_Hash_Call) RunAndReturn(run func(value []byte) string) *MockHashService_Hash_Call

type MockTokenRepository 

type MockTokenRepository struct {
	mock.Mock
}

MockTokenRepository is an autogenerated mock type for the TokenRepository type

func NewMockTokenRepository 

func NewMockTokenRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTokenRepository

NewMockTokenRepository creates a new instance of MockTokenRepository. 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 (*MockTokenRepository) CountExpired 

func (_mock *MockTokenRepository) CountExpired(ctx context.Context, olderThan time.Time) (int64, error)

CountExpired provides a mock function for the type MockTokenRepository

func (*MockTokenRepository) Create 

func (_mock *MockTokenRepository) Create(ctx context.Context, token *domain0.Token) error

Create provides a mock function for the type MockTokenRepository

func (*MockTokenRepository) DeleteExpired 

func (_mock *MockTokenRepository) DeleteExpired(ctx context.Context, olderThan time.Time) (int64, error)

DeleteExpired provides a mock function for the type MockTokenRepository

func (*MockTokenRepository) EXPECT 

func (_m *MockTokenRepository) EXPECT() *MockTokenRepository_Expecter

func (*MockTokenRepository) GetByToken 

func (_mock *MockTokenRepository) GetByToken(ctx context.Context, token string) (*domain0.Token, error)

GetByToken provides a mock function for the type MockTokenRepository

func (*MockTokenRepository) GetByValueHash 

func (_mock *MockTokenRepository) GetByValueHash(ctx context.Context, keyID uuid.UUID, valueHash string) (*domain0.Token, error)

GetByValueHash provides a mock function for the type MockTokenRepository

func (*MockTokenRepository) Revoke 

func (_mock *MockTokenRepository) Revoke(ctx context.Context, token string) error

Revoke provides a mock function for the type MockTokenRepository

type MockTokenRepository_CountExpired_Call 

type MockTokenRepository_CountExpired_Call struct {
	*mock.Call
}

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

func (*MockTokenRepository_CountExpired_Call) Return 

func (_c *MockTokenRepository_CountExpired_Call) Return(n int64, err error) *MockTokenRepository_CountExpired_Call

func (*MockTokenRepository_CountExpired_Call) Run 

func (_c *MockTokenRepository_CountExpired_Call) Run(run func(ctx context.Context, olderThan time.Time)) *MockTokenRepository_CountExpired_Call

func (*MockTokenRepository_CountExpired_Call) RunAndReturn 

func (_c *MockTokenRepository_CountExpired_Call) RunAndReturn(run func(ctx context.Context, olderThan time.Time) (int64, error)) *MockTokenRepository_CountExpired_Call

type MockTokenRepository_Create_Call 

type MockTokenRepository_Create_Call struct {
	*mock.Call
}

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

func (*MockTokenRepository_Create_Call) Return 

func (_c *MockTokenRepository_Create_Call) Return(err error) *MockTokenRepository_Create_Call

func (*MockTokenRepository_Create_Call) Run 

func (_c *MockTokenRepository_Create_Call) Run(run func(ctx context.Context, token *domain0.Token)) *MockTokenRepository_Create_Call

func (*MockTokenRepository_Create_Call) RunAndReturn 

func (_c *MockTokenRepository_Create_Call) RunAndReturn(run func(ctx context.Context, token *domain0.Token) error) *MockTokenRepository_Create_Call

type MockTokenRepository_DeleteExpired_Call 

type MockTokenRepository_DeleteExpired_Call struct {
	*mock.Call
}

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

func (*MockTokenRepository_DeleteExpired_Call) Return 

func (_c *MockTokenRepository_DeleteExpired_Call) Return(n int64, err error) *MockTokenRepository_DeleteExpired_Call

func (*MockTokenRepository_DeleteExpired_Call) Run 

func (_c *MockTokenRepository_DeleteExpired_Call) Run(run func(ctx context.Context, olderThan time.Time)) *MockTokenRepository_DeleteExpired_Call

func (*MockTokenRepository_DeleteExpired_Call) RunAndReturn 

func (_c *MockTokenRepository_DeleteExpired_Call) RunAndReturn(run func(ctx context.Context, olderThan time.Time) (int64, error)) *MockTokenRepository_DeleteExpired_Call

type MockTokenRepository_Expecter 

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

func (*MockTokenRepository_Expecter) CountExpired 

func (_e *MockTokenRepository_Expecter) CountExpired(ctx interface{}, olderThan interface{}) *MockTokenRepository_CountExpired_Call

CountExpired is a helper method to define mock.On call

  • ctx context.Context
  • olderThan time.Time

func (*MockTokenRepository_Expecter) Create 

func (_e *MockTokenRepository_Expecter) Create(ctx interface{}, token interface{}) *MockTokenRepository_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • token *domain0.Token

func (*MockTokenRepository_Expecter) DeleteExpired 

func (_e *MockTokenRepository_Expecter) DeleteExpired(ctx interface{}, olderThan interface{}) *MockTokenRepository_DeleteExpired_Call

DeleteExpired is a helper method to define mock.On call

  • ctx context.Context
  • olderThan time.Time

func (*MockTokenRepository_Expecter) GetByToken 

func (_e *MockTokenRepository_Expecter) GetByToken(ctx interface{}, token interface{}) *MockTokenRepository_GetByToken_Call

GetByToken is a helper method to define mock.On call

  • ctx context.Context
  • token string

func (*MockTokenRepository_Expecter) GetByValueHash 

func (_e *MockTokenRepository_Expecter) GetByValueHash(ctx interface{}, keyID interface{}, valueHash interface{}) *MockTokenRepository_GetByValueHash_Call

GetByValueHash is a helper method to define mock.On call

  • ctx context.Context
  • keyID uuid.UUID
  • valueHash string

func (*MockTokenRepository_Expecter) Revoke 

func (_e *MockTokenRepository_Expecter) Revoke(ctx interface{}, token interface{}) *MockTokenRepository_Revoke_Call

Revoke is a helper method to define mock.On call

  • ctx context.Context
  • token string

type MockTokenRepository_GetByToken_Call 

type MockTokenRepository_GetByToken_Call struct {
	*mock.Call
}

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

func (*MockTokenRepository_GetByToken_Call) Return 

func (_c *MockTokenRepository_GetByToken_Call) Return(token1 *domain0.Token, err error) *MockTokenRepository_GetByToken_Call

func (*MockTokenRepository_GetByToken_Call) Run 

func (_c *MockTokenRepository_GetByToken_Call) Run(run func(ctx context.Context, token string)) *MockTokenRepository_GetByToken_Call

func (*MockTokenRepository_GetByToken_Call) RunAndReturn 

func (_c *MockTokenRepository_GetByToken_Call) RunAndReturn(run func(ctx context.Context, token string) (*domain0.Token, error)) *MockTokenRepository_GetByToken_Call

type MockTokenRepository_GetByValueHash_Call 

type MockTokenRepository_GetByValueHash_Call struct {
	*mock.Call
}

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

func (*MockTokenRepository_GetByValueHash_Call) Return 

func (_c *MockTokenRepository_GetByValueHash_Call) Return(token *domain0.Token, err error) *MockTokenRepository_GetByValueHash_Call

func (*MockTokenRepository_GetByValueHash_Call) Run 

func (_c *MockTokenRepository_GetByValueHash_Call) Run(run func(ctx context.Context, keyID uuid.UUID, valueHash string)) *MockTokenRepository_GetByValueHash_Call

func (*MockTokenRepository_GetByValueHash_Call) RunAndReturn 

func (_c *MockTokenRepository_GetByValueHash_Call) RunAndReturn(run func(ctx context.Context, keyID uuid.UUID, valueHash string) (*domain0.Token, error)) *MockTokenRepository_GetByValueHash_Call

type MockTokenRepository_Revoke_Call 

type MockTokenRepository_Revoke_Call struct {
	*mock.Call
}

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

func (*MockTokenRepository_Revoke_Call) Return 

func (_c *MockTokenRepository_Revoke_Call) Return(err error) *MockTokenRepository_Revoke_Call

func (*MockTokenRepository_Revoke_Call) Run 

func (_c *MockTokenRepository_Revoke_Call) Run(run func(ctx context.Context, token string)) *MockTokenRepository_Revoke_Call

func (*MockTokenRepository_Revoke_Call) RunAndReturn 

func (_c *MockTokenRepository_Revoke_Call) RunAndReturn(run func(ctx context.Context, token string) error) *MockTokenRepository_Revoke_Call

type MockTokenizationKeyRepository 

type MockTokenizationKeyRepository struct {
	mock.Mock
}

MockTokenizationKeyRepository is an autogenerated mock type for the TokenizationKeyRepository type

func NewMockTokenizationKeyRepository 

func NewMockTokenizationKeyRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTokenizationKeyRepository

NewMockTokenizationKeyRepository creates a new instance of MockTokenizationKeyRepository. 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 (*MockTokenizationKeyRepository) Create 

func (_mock *MockTokenizationKeyRepository) Create(ctx context.Context, key *domain0.TokenizationKey) error

Create provides a mock function for the type MockTokenizationKeyRepository

func (*MockTokenizationKeyRepository) Delete 

func (_mock *MockTokenizationKeyRepository) Delete(ctx context.Context, keyID uuid.UUID) error

Delete provides a mock function for the type MockTokenizationKeyRepository

func (*MockTokenizationKeyRepository) EXPECT 

func (_m *MockTokenizationKeyRepository) EXPECT() *MockTokenizationKeyRepository_Expecter

func (*MockTokenizationKeyRepository) Get 

func (_mock *MockTokenizationKeyRepository) Get(ctx context.Context, keyID uuid.UUID) (*domain0.TokenizationKey, error)

Get provides a mock function for the type MockTokenizationKeyRepository

func (*MockTokenizationKeyRepository) GetByName 

func (_mock *MockTokenizationKeyRepository) GetByName(ctx context.Context, name string) (*domain0.TokenizationKey, error)

GetByName provides a mock function for the type MockTokenizationKeyRepository

func (*MockTokenizationKeyRepository) GetByNameAndVersion 

func (_mock *MockTokenizationKeyRepository) GetByNameAndVersion(ctx context.Context, name string, version uint) (*domain0.TokenizationKey, error)

GetByNameAndVersion provides a mock function for the type MockTokenizationKeyRepository

type MockTokenizationKeyRepository_Create_Call 

type MockTokenizationKeyRepository_Create_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyRepository_Create_Call) Return 

func (_c *MockTokenizationKeyRepository_Create_Call) Return(err error) *MockTokenizationKeyRepository_Create_Call

func (*MockTokenizationKeyRepository_Create_Call) Run 

func (_c *MockTokenizationKeyRepository_Create_Call) Run(run func(ctx context.Context, key *domain0.TokenizationKey)) *MockTokenizationKeyRepository_Create_Call

func (*MockTokenizationKeyRepository_Create_Call) RunAndReturn 

func (_c *MockTokenizationKeyRepository_Create_Call) RunAndReturn(run func(ctx context.Context, key *domain0.TokenizationKey) error) *MockTokenizationKeyRepository_Create_Call

type MockTokenizationKeyRepository_Delete_Call 

type MockTokenizationKeyRepository_Delete_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyRepository_Delete_Call) Return 

func (_c *MockTokenizationKeyRepository_Delete_Call) Return(err error) *MockTokenizationKeyRepository_Delete_Call

func (*MockTokenizationKeyRepository_Delete_Call) Run 

func (_c *MockTokenizationKeyRepository_Delete_Call) Run(run func(ctx context.Context, keyID uuid.UUID)) *MockTokenizationKeyRepository_Delete_Call

func (*MockTokenizationKeyRepository_Delete_Call) RunAndReturn 

func (_c *MockTokenizationKeyRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, keyID uuid.UUID) error) *MockTokenizationKeyRepository_Delete_Call

type MockTokenizationKeyRepository_Expecter 

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

func (*MockTokenizationKeyRepository_Expecter) Create 

func (_e *MockTokenizationKeyRepository_Expecter) Create(ctx interface{}, key interface{}) *MockTokenizationKeyRepository_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • key *domain0.TokenizationKey

func (*MockTokenizationKeyRepository_Expecter) Delete 

func (_e *MockTokenizationKeyRepository_Expecter) Delete(ctx interface{}, keyID interface{}) *MockTokenizationKeyRepository_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • keyID uuid.UUID

func (*MockTokenizationKeyRepository_Expecter) Get 

func (_e *MockTokenizationKeyRepository_Expecter) Get(ctx interface{}, keyID interface{}) *MockTokenizationKeyRepository_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • keyID uuid.UUID

func (*MockTokenizationKeyRepository_Expecter) GetByName 

func (_e *MockTokenizationKeyRepository_Expecter) GetByName(ctx interface{}, name interface{}) *MockTokenizationKeyRepository_GetByName_Call

GetByName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockTokenizationKeyRepository_Expecter) GetByNameAndVersion 

func (_e *MockTokenizationKeyRepository_Expecter) GetByNameAndVersion(ctx interface{}, name interface{}, version interface{}) *MockTokenizationKeyRepository_GetByNameAndVersion_Call

GetByNameAndVersion is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • version uint

type MockTokenizationKeyRepository_GetByNameAndVersion_Call 

type MockTokenizationKeyRepository_GetByNameAndVersion_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyRepository_GetByNameAndVersion_Call) Return 

func (_c *MockTokenizationKeyRepository_GetByNameAndVersion_Call) Return(tokenizationKey *domain0.TokenizationKey, err error) *MockTokenizationKeyRepository_GetByNameAndVersion_Call

func (*MockTokenizationKeyRepository_GetByNameAndVersion_Call) Run 

func (_c *MockTokenizationKeyRepository_GetByNameAndVersion_Call) Run(run func(ctx context.Context, name string, version uint)) *MockTokenizationKeyRepository_GetByNameAndVersion_Call

func (*MockTokenizationKeyRepository_GetByNameAndVersion_Call) RunAndReturn 

func (_c *MockTokenizationKeyRepository_GetByNameAndVersion_Call) RunAndReturn(run func(ctx context.Context, name string, version uint) (*domain0.TokenizationKey, error)) *MockTokenizationKeyRepository_GetByNameAndVersion_Call

type MockTokenizationKeyRepository_GetByName_Call 

type MockTokenizationKeyRepository_GetByName_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyRepository_GetByName_Call) Return 

func (_c *MockTokenizationKeyRepository_GetByName_Call) Return(tokenizationKey *domain0.TokenizationKey, err error) *MockTokenizationKeyRepository_GetByName_Call

func (*MockTokenizationKeyRepository_GetByName_Call) Run 

func (_c *MockTokenizationKeyRepository_GetByName_Call) Run(run func(ctx context.Context, name string)) *MockTokenizationKeyRepository_GetByName_Call

func (*MockTokenizationKeyRepository_GetByName_Call) RunAndReturn 

func (_c *MockTokenizationKeyRepository_GetByName_Call) RunAndReturn(run func(ctx context.Context, name string) (*domain0.TokenizationKey, error)) *MockTokenizationKeyRepository_GetByName_Call

type MockTokenizationKeyRepository_Get_Call 

type MockTokenizationKeyRepository_Get_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyRepository_Get_Call) Return 

func (_c *MockTokenizationKeyRepository_Get_Call) Return(tokenizationKey *domain0.TokenizationKey, err error) *MockTokenizationKeyRepository_Get_Call

func (*MockTokenizationKeyRepository_Get_Call) Run 

func (_c *MockTokenizationKeyRepository_Get_Call) Run(run func(ctx context.Context, keyID uuid.UUID)) *MockTokenizationKeyRepository_Get_Call

func (*MockTokenizationKeyRepository_Get_Call) RunAndReturn 

func (_c *MockTokenizationKeyRepository_Get_Call) RunAndReturn(run func(ctx context.Context, keyID uuid.UUID) (*domain0.TokenizationKey, error)) *MockTokenizationKeyRepository_Get_Call

type MockTokenizationKeyUseCase 

type MockTokenizationKeyUseCase struct {
	mock.Mock
}

MockTokenizationKeyUseCase is an autogenerated mock type for the TokenizationKeyUseCase type

func NewMockTokenizationKeyUseCase 

func NewMockTokenizationKeyUseCase(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTokenizationKeyUseCase

NewMockTokenizationKeyUseCase creates a new instance of MockTokenizationKeyUseCase. 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 (*MockTokenizationKeyUseCase) Create 

func (_mock *MockTokenizationKeyUseCase) Create(ctx context.Context, name string, formatType domain0.FormatType, isDeterministic bool, alg domain.Algorithm) (*domain0.TokenizationKey, error)

Create provides a mock function for the type MockTokenizationKeyUseCase

func (*MockTokenizationKeyUseCase) Delete 

func (_mock *MockTokenizationKeyUseCase) Delete(ctx context.Context, keyID uuid.UUID) error

Delete provides a mock function for the type MockTokenizationKeyUseCase

func (*MockTokenizationKeyUseCase) EXPECT 

func (_m *MockTokenizationKeyUseCase) EXPECT() *MockTokenizationKeyUseCase_Expecter

func (*MockTokenizationKeyUseCase) Rotate 

func (_mock *MockTokenizationKeyUseCase) Rotate(ctx context.Context, name string, formatType domain0.FormatType, isDeterministic bool, alg domain.Algorithm) (*domain0.TokenizationKey, error)

Rotate provides a mock function for the type MockTokenizationKeyUseCase

type MockTokenizationKeyUseCase_Create_Call 

type MockTokenizationKeyUseCase_Create_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyUseCase_Create_Call) Return 

func (_c *MockTokenizationKeyUseCase_Create_Call) Return(tokenizationKey *domain0.TokenizationKey, err error) *MockTokenizationKeyUseCase_Create_Call

func (*MockTokenizationKeyUseCase_Create_Call) Run 

func (_c *MockTokenizationKeyUseCase_Create_Call) Run(run func(ctx context.Context, name string, formatType domain0.FormatType, isDeterministic bool, alg domain.Algorithm)) *MockTokenizationKeyUseCase_Create_Call

func (*MockTokenizationKeyUseCase_Create_Call) RunAndReturn 

func (_c *MockTokenizationKeyUseCase_Create_Call) RunAndReturn(run func(ctx context.Context, name string, formatType domain0.FormatType, isDeterministic bool, alg domain.Algorithm) (*domain0.TokenizationKey, error)) *MockTokenizationKeyUseCase_Create_Call

type MockTokenizationKeyUseCase_Delete_Call 

type MockTokenizationKeyUseCase_Delete_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyUseCase_Delete_Call) Return 

func (_c *MockTokenizationKeyUseCase_Delete_Call) Return(err error) *MockTokenizationKeyUseCase_Delete_Call

func (*MockTokenizationKeyUseCase_Delete_Call) Run 

func (_c *MockTokenizationKeyUseCase_Delete_Call) Run(run func(ctx context.Context, keyID uuid.UUID)) *MockTokenizationKeyUseCase_Delete_Call

func (*MockTokenizationKeyUseCase_Delete_Call) RunAndReturn 

func (_c *MockTokenizationKeyUseCase_Delete_Call) RunAndReturn(run func(ctx context.Context, keyID uuid.UUID) error) *MockTokenizationKeyUseCase_Delete_Call

type MockTokenizationKeyUseCase_Expecter 

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

func (*MockTokenizationKeyUseCase_Expecter) Create 

func (_e *MockTokenizationKeyUseCase_Expecter) Create(ctx interface{}, name interface{}, formatType interface{}, isDeterministic interface{}, alg interface{}) *MockTokenizationKeyUseCase_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • formatType domain0.FormatType
  • isDeterministic bool
  • alg domain.Algorithm

func (*MockTokenizationKeyUseCase_Expecter) Delete 

func (_e *MockTokenizationKeyUseCase_Expecter) Delete(ctx interface{}, keyID interface{}) *MockTokenizationKeyUseCase_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • keyID uuid.UUID

func (*MockTokenizationKeyUseCase_Expecter) Rotate 

func (_e *MockTokenizationKeyUseCase_Expecter) Rotate(ctx interface{}, name interface{}, formatType interface{}, isDeterministic interface{}, alg interface{}) *MockTokenizationKeyUseCase_Rotate_Call

Rotate is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • formatType domain0.FormatType
  • isDeterministic bool
  • alg domain.Algorithm

type MockTokenizationKeyUseCase_Rotate_Call 

type MockTokenizationKeyUseCase_Rotate_Call struct {
	*mock.Call
}

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

func (*MockTokenizationKeyUseCase_Rotate_Call) Return 

func (_c *MockTokenizationKeyUseCase_Rotate_Call) Return(tokenizationKey *domain0.TokenizationKey, err error) *MockTokenizationKeyUseCase_Rotate_Call

func (*MockTokenizationKeyUseCase_Rotate_Call) Run 

func (_c *MockTokenizationKeyUseCase_Rotate_Call) Run(run func(ctx context.Context, name string, formatType domain0.FormatType, isDeterministic bool, alg domain.Algorithm)) *MockTokenizationKeyUseCase_Rotate_Call

func (*MockTokenizationKeyUseCase_Rotate_Call) RunAndReturn 

func (_c *MockTokenizationKeyUseCase_Rotate_Call) RunAndReturn(run func(ctx context.Context, name string, formatType domain0.FormatType, isDeterministic bool, alg domain.Algorithm) (*domain0.TokenizationKey, error)) *MockTokenizationKeyUseCase_Rotate_Call

type MockTokenizationUseCase 

type MockTokenizationUseCase struct {
	mock.Mock
}

MockTokenizationUseCase is an autogenerated mock type for the TokenizationUseCase type

func NewMockTokenizationUseCase 

func NewMockTokenizationUseCase(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTokenizationUseCase

NewMockTokenizationUseCase creates a new instance of MockTokenizationUseCase. 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 (*MockTokenizationUseCase) CleanupExpired 

func (_mock *MockTokenizationUseCase) CleanupExpired(ctx context.Context, days int, dryRun bool) (int64, error)

CleanupExpired provides a mock function for the type MockTokenizationUseCase

func (*MockTokenizationUseCase) Detokenize 

func (_mock *MockTokenizationUseCase) Detokenize(ctx context.Context, token string) ([]byte, map[string]any, error)

Detokenize provides a mock function for the type MockTokenizationUseCase

func (*MockTokenizationUseCase) EXPECT 

func (_m *MockTokenizationUseCase) EXPECT() *MockTokenizationUseCase_Expecter

func (*MockTokenizationUseCase) Revoke 

func (_mock *MockTokenizationUseCase) Revoke(ctx context.Context, token string) error

Revoke provides a mock function for the type MockTokenizationUseCase

func (*MockTokenizationUseCase) Tokenize 

func (_mock *MockTokenizationUseCase) Tokenize(ctx context.Context, keyName string, plaintext []byte, metadata map[string]any, expiresAt *time.Time) (*domain0.Token, error)

Tokenize provides a mock function for the type MockTokenizationUseCase

func (*MockTokenizationUseCase) Validate 

func (_mock *MockTokenizationUseCase) Validate(ctx context.Context, token string) (bool, error)

Validate provides a mock function for the type MockTokenizationUseCase

type MockTokenizationUseCase_CleanupExpired_Call 

type MockTokenizationUseCase_CleanupExpired_Call struct {
	*mock.Call
}

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

func (*MockTokenizationUseCase_CleanupExpired_Call) Return 

func (_c *MockTokenizationUseCase_CleanupExpired_Call) Return(n int64, err error) *MockTokenizationUseCase_CleanupExpired_Call

func (*MockTokenizationUseCase_CleanupExpired_Call) Run 

func (_c *MockTokenizationUseCase_CleanupExpired_Call) Run(run func(ctx context.Context, days int, dryRun bool)) *MockTokenizationUseCase_CleanupExpired_Call

func (*MockTokenizationUseCase_CleanupExpired_Call) RunAndReturn 

func (_c *MockTokenizationUseCase_CleanupExpired_Call) RunAndReturn(run func(ctx context.Context, days int, dryRun bool) (int64, error)) *MockTokenizationUseCase_CleanupExpired_Call

type MockTokenizationUseCase_Detokenize_Call 

type MockTokenizationUseCase_Detokenize_Call struct {
	*mock.Call
}

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

func (*MockTokenizationUseCase_Detokenize_Call) Return 

func (_c *MockTokenizationUseCase_Detokenize_Call) Return(plaintext []byte, metadata map[string]any, err error) *MockTokenizationUseCase_Detokenize_Call

func (*MockTokenizationUseCase_Detokenize_Call) Run 

func (_c *MockTokenizationUseCase_Detokenize_Call) Run(run func(ctx context.Context, token string)) *MockTokenizationUseCase_Detokenize_Call

func (*MockTokenizationUseCase_Detokenize_Call) RunAndReturn 

func (_c *MockTokenizationUseCase_Detokenize_Call) RunAndReturn(run func(ctx context.Context, token string) ([]byte, map[string]any, error)) *MockTokenizationUseCase_Detokenize_Call

type MockTokenizationUseCase_Expecter 

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

func (*MockTokenizationUseCase_Expecter) CleanupExpired 

func (_e *MockTokenizationUseCase_Expecter) CleanupExpired(ctx interface{}, days interface{}, dryRun interface{}) *MockTokenizationUseCase_CleanupExpired_Call

CleanupExpired is a helper method to define mock.On call

  • ctx context.Context
  • days int
  • dryRun bool

func (*MockTokenizationUseCase_Expecter) Detokenize 

func (_e *MockTokenizationUseCase_Expecter) Detokenize(ctx interface{}, token interface{}) *MockTokenizationUseCase_Detokenize_Call

Detokenize is a helper method to define mock.On call

  • ctx context.Context
  • token string

func (*MockTokenizationUseCase_Expecter) Revoke 

func (_e *MockTokenizationUseCase_Expecter) Revoke(ctx interface{}, token interface{}) *MockTokenizationUseCase_Revoke_Call

Revoke is a helper method to define mock.On call

  • ctx context.Context
  • token string

func (*MockTokenizationUseCase_Expecter) Tokenize 

func (_e *MockTokenizationUseCase_Expecter) Tokenize(ctx interface{}, keyName interface{}, plaintext interface{}, metadata interface{}, expiresAt interface{}) *MockTokenizationUseCase_Tokenize_Call

Tokenize is a helper method to define mock.On call

  • ctx context.Context
  • keyName string
  • plaintext []byte
  • metadata map[string]any
  • expiresAt *time.Time

func (*MockTokenizationUseCase_Expecter) Validate 

func (_e *MockTokenizationUseCase_Expecter) Validate(ctx interface{}, token interface{}) *MockTokenizationUseCase_Validate_Call

Validate is a helper method to define mock.On call

  • ctx context.Context
  • token string

type MockTokenizationUseCase_Revoke_Call 

type MockTokenizationUseCase_Revoke_Call struct {
	*mock.Call
}

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

func (*MockTokenizationUseCase_Revoke_Call) Return 

func (_c *MockTokenizationUseCase_Revoke_Call) Return(err error) *MockTokenizationUseCase_Revoke_Call

func (*MockTokenizationUseCase_Revoke_Call) Run 

func (_c *MockTokenizationUseCase_Revoke_Call) Run(run func(ctx context.Context, token string)) *MockTokenizationUseCase_Revoke_Call

func (*MockTokenizationUseCase_Revoke_Call) RunAndReturn 

func (_c *MockTokenizationUseCase_Revoke_Call) RunAndReturn(run func(ctx context.Context, token string) error) *MockTokenizationUseCase_Revoke_Call

type MockTokenizationUseCase_Tokenize_Call 

type MockTokenizationUseCase_Tokenize_Call struct {
	*mock.Call
}

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

func (*MockTokenizationUseCase_Tokenize_Call) Return 

func (_c *MockTokenizationUseCase_Tokenize_Call) Return(token *domain0.Token, err error) *MockTokenizationUseCase_Tokenize_Call

func (*MockTokenizationUseCase_Tokenize_Call) Run 

func (_c *MockTokenizationUseCase_Tokenize_Call) Run(run func(ctx context.Context, keyName string, plaintext []byte, metadata map[string]any, expiresAt *time.Time)) *MockTokenizationUseCase_Tokenize_Call

func (*MockTokenizationUseCase_Tokenize_Call) RunAndReturn 

func (_c *MockTokenizationUseCase_Tokenize_Call) RunAndReturn(run func(ctx context.Context, keyName string, plaintext []byte, metadata map[string]any, expiresAt *time.Time) (*domain0.Token, error)) *MockTokenizationUseCase_Tokenize_Call

type MockTokenizationUseCase_Validate_Call 

type MockTokenizationUseCase_Validate_Call struct {
	*mock.Call
}

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

func (*MockTokenizationUseCase_Validate_Call) Return 

func (_c *MockTokenizationUseCase_Validate_Call) Return(b bool, err error) *MockTokenizationUseCase_Validate_Call

func (*MockTokenizationUseCase_Validate_Call) Run 

func (_c *MockTokenizationUseCase_Validate_Call) Run(run func(ctx context.Context, token string)) *MockTokenizationUseCase_Validate_Call

func (*MockTokenizationUseCase_Validate_Call) RunAndReturn 

func (_c *MockTokenizationUseCase_Validate_Call) RunAndReturn(run func(ctx context.Context, token string) (bool, error)) *MockTokenizationUseCase_Validate_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.