mocks

package
v0.15.0 Latest Latest
Warning

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

 Go to latest Published: Oct 16, 2023 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Cache 

type Cache[K comparable, V interface{}] struct {
	mock.Mock
}

Cache is an autogenerated mock type for the Cache type

func NewCache 

func NewCache[K comparable, V interface{}](t mockConstructorTestingTNewCache) *Cache[K, V]

NewCache creates a new instance of Cache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*Cache[K, V]) Delete 

func (_m *Cache[K, V]) Delete(ctx context.Context, key K, options ...trcache.IOption[trcache.IDeleteOpt]) error

Delete provides a mock function with given fields: ctx, key, options

func (*Cache[K, V]) EXPECT 

func (_m *Cache[K, V]) EXPECT() *Cache_Expecter[K, V]

func (*Cache[K, V]) Get 

func (_m *Cache[K, V]) Get(ctx context.Context, key K, options ...trcache.IOption[trcache.IGetOpt]) (V, error)

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

func (*Cache[K, V]) Name 

func (_m *Cache[K, V]) Name() string

Name provides a mock function with given fields:

func (*Cache[K, V]) Set 

func (_m *Cache[K, V]) Set(ctx context.Context, key K, value V, options ...trcache.IOption[trcache.ISetOpt]) error

Set provides a mock function with given fields: ctx, key, value, options

type CacheRefreshFunc 

type CacheRefreshFunc[K comparable, V interface{}] struct {
	mock.Mock
}

CacheRefreshFunc is an autogenerated mock type for the CacheRefreshFunc type

func NewCacheRefreshFunc 

func NewCacheRefreshFunc[K comparable, V interface{}](t mockConstructorTestingTNewCacheRefreshFunc) *CacheRefreshFunc[K, V]

NewCacheRefreshFunc creates a new instance of CacheRefreshFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*CacheRefreshFunc[K, V]) EXPECT 

func (_m *CacheRefreshFunc[K, V]) EXPECT() *CacheRefreshFunc_Expecter[K, V]

func (*CacheRefreshFunc[K, V]) Execute 

func (_m *CacheRefreshFunc[K, V]) Execute(ctx context.Context, key K, options trcache.RefreshFuncOptions) (V, error)

Execute provides a mock function with given fields: ctx, key, options

type CacheRefreshFunc_Execute_Call 

type CacheRefreshFunc_Execute_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*CacheRefreshFunc_Execute_Call[K, V]) Return 

func (_c *CacheRefreshFunc_Execute_Call[K, V]) Return(_a0 V, _a1 error) *CacheRefreshFunc_Execute_Call[K, V]

func (*CacheRefreshFunc_Execute_Call[K, V]) Run 

func (_c *CacheRefreshFunc_Execute_Call[K, V]) Run(run func(ctx context.Context, key K, options trcache.RefreshFuncOptions)) *CacheRefreshFunc_Execute_Call[K, V]

func (*CacheRefreshFunc_Execute_Call[K, V]) RunAndReturn 

func (_c *CacheRefreshFunc_Execute_Call[K, V]) RunAndReturn(run func(context.Context, K, trcache.RefreshFuncOptions) (V, error)) *CacheRefreshFunc_Execute_Call[K, V]

type CacheRefreshFunc_Expecter 

type CacheRefreshFunc_Expecter[K comparable, V interface{}] struct {
	// contains filtered or unexported fields
}

func (*CacheRefreshFunc_Expecter[K, V]) Execute 

func (_e *CacheRefreshFunc_Expecter[K, V]) Execute(ctx interface{}, key interface{}, options interface{}) *CacheRefreshFunc_Execute_Call[K, V]

Execute is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • options trcache.RefreshFuncOptions

type Cache_Delete_Call 

type Cache_Delete_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*Cache_Delete_Call[K, V]) Return 

func (_c *Cache_Delete_Call[K, V]) Return(_a0 error) *Cache_Delete_Call[K, V]

func (*Cache_Delete_Call[K, V]) Run 

func (_c *Cache_Delete_Call[K, V]) Run(run func(ctx context.Context, key K, options ...trcache.IOption[trcache.IDeleteOpt])) *Cache_Delete_Call[K, V]

func (*Cache_Delete_Call[K, V]) RunAndReturn 

func (_c *Cache_Delete_Call[K, V]) RunAndReturn(run func(context.Context, K, ...trcache.IOption[trcache.IDeleteOpt]) error) *Cache_Delete_Call[K, V]

type Cache_Expecter 

type Cache_Expecter[K comparable, V interface{}] struct {
	// contains filtered or unexported fields
}

func (*Cache_Expecter[K, V]) Delete 

func (_e *Cache_Expecter[K, V]) Delete(ctx interface{}, key interface{}, options ...interface{}) *Cache_Delete_Call[K, V]

Delete is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • options ...trcache.IOption[trcache.IDeleteOpt]

func (*Cache_Expecter[K, V]) Get 

func (_e *Cache_Expecter[K, V]) Get(ctx interface{}, key interface{}, options ...interface{}) *Cache_Get_Call[K, V]

Get is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • options ...trcache.IOption[trcache.IGetOpt]

func (*Cache_Expecter[K, V]) Name 

func (_e *Cache_Expecter[K, V]) Name() *Cache_Name_Call[K, V]

Name is a helper method to define mock.On call

func (*Cache_Expecter[K, V]) Set 

func (_e *Cache_Expecter[K, V]) Set(ctx interface{}, key interface{}, value interface{}, options ...interface{}) *Cache_Set_Call[K, V]

Set is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • value V
  • options ...trcache.IOption[trcache.ISetOpt]

type Cache_Get_Call 

type Cache_Get_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*Cache_Get_Call[K, V]) Return 

func (_c *Cache_Get_Call[K, V]) Return(_a0 V, _a1 error) *Cache_Get_Call[K, V]

func (*Cache_Get_Call[K, V]) Run 

func (_c *Cache_Get_Call[K, V]) Run(run func(ctx context.Context, key K, options ...trcache.IOption[trcache.IGetOpt])) *Cache_Get_Call[K, V]

func (*Cache_Get_Call[K, V]) RunAndReturn 

func (_c *Cache_Get_Call[K, V]) RunAndReturn(run func(context.Context, K, ...trcache.IOption[trcache.IGetOpt]) (V, error)) *Cache_Get_Call[K, V]

type Cache_Name_Call 

type Cache_Name_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*Cache_Name_Call[K, V]) Return 

func (_c *Cache_Name_Call[K, V]) Return(_a0 string) *Cache_Name_Call[K, V]

func (*Cache_Name_Call[K, V]) Run 

func (_c *Cache_Name_Call[K, V]) Run(run func()) *Cache_Name_Call[K, V]

func (*Cache_Name_Call[K, V]) RunAndReturn 

func (_c *Cache_Name_Call[K, V]) RunAndReturn(run func() string) *Cache_Name_Call[K, V]

type Cache_Set_Call 

type Cache_Set_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*Cache_Set_Call[K, V]) Return 

func (_c *Cache_Set_Call[K, V]) Return(_a0 error) *Cache_Set_Call[K, V]

func (*Cache_Set_Call[K, V]) Run 

func (_c *Cache_Set_Call[K, V]) Run(run func(ctx context.Context, key K, value V, options ...trcache.IOption[trcache.ISetOpt])) *Cache_Set_Call[K, V]

func (*Cache_Set_Call[K, V]) RunAndReturn 

func (_c *Cache_Set_Call[K, V]) RunAndReturn(run func(context.Context, K, V, ...trcache.IOption[trcache.ISetOpt]) error) *Cache_Set_Call[K, V]

type Codec 

type Codec[V interface{}] struct {
	mock.Mock
}

Codec is an autogenerated mock type for the Codec type

func NewCodec 

func NewCodec[V interface{}](t mockConstructorTestingTNewCodec) *Codec[V]

NewCodec creates a new instance of Codec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*Codec[V]) Decode 

func (_m *Codec[V]) Decode(ctx context.Context, data interface{}) (V, error)

Decode provides a mock function with given fields: ctx, data

func (*Codec[V]) EXPECT 

func (_m *Codec[V]) EXPECT() *Codec_Expecter[V]

func (*Codec[V]) Encode 

func (_m *Codec[V]) Encode(ctx context.Context, data V) (interface{}, error)

Encode provides a mock function with given fields: ctx, data

type Codec_Decode_Call 

type Codec_Decode_Call[V interface{}] struct {
	*mock.Call
}

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

func (*Codec_Decode_Call[V]) Return 

func (_c *Codec_Decode_Call[V]) Return(_a0 V, _a1 error) *Codec_Decode_Call[V]

func (*Codec_Decode_Call[V]) Run 

func (_c *Codec_Decode_Call[V]) Run(run func(ctx context.Context, data interface{})) *Codec_Decode_Call[V]

func (*Codec_Decode_Call[V]) RunAndReturn 

func (_c *Codec_Decode_Call[V]) RunAndReturn(run func(context.Context, interface{}) (V, error)) *Codec_Decode_Call[V]

type Codec_Encode_Call 

type Codec_Encode_Call[V interface{}] struct {
	*mock.Call
}

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

func (*Codec_Encode_Call[V]) Return 

func (_c *Codec_Encode_Call[V]) Return(_a0 interface{}, _a1 error) *Codec_Encode_Call[V]

func (*Codec_Encode_Call[V]) Run 

func (_c *Codec_Encode_Call[V]) Run(run func(ctx context.Context, data V)) *Codec_Encode_Call[V]

func (*Codec_Encode_Call[V]) RunAndReturn 

func (_c *Codec_Encode_Call[V]) RunAndReturn(run func(context.Context, V) (interface{}, error)) *Codec_Encode_Call[V]

type Codec_Expecter 

type Codec_Expecter[V interface{}] struct {
	// contains filtered or unexported fields
}

func (*Codec_Expecter[V]) Decode 

func (_e *Codec_Expecter[V]) Decode(ctx interface{}, data interface{}) *Codec_Decode_Call[V]

Decode is a helper method to define mock.On call

  • ctx context.Context
  • data interface{}

func (*Codec_Expecter[V]) Encode 

func (_e *Codec_Expecter[V]) Encode(ctx interface{}, data interface{}) *Codec_Encode_Call[V]

Encode is a helper method to define mock.On call

  • ctx context.Context
  • data V

type RefreshCache 

type RefreshCache[K comparable, V interface{}] struct {
	mock.Mock
}

RefreshCache is an autogenerated mock type for the RefreshCache type

func NewRefreshCache 

func NewRefreshCache[K comparable, V interface{}](t mockConstructorTestingTNewRefreshCache) *RefreshCache[K, V]

NewRefreshCache creates a new instance of RefreshCache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*RefreshCache[K, V]) Delete 

func (_m *RefreshCache[K, V]) Delete(ctx context.Context, key K, options ...trcache.IOption[trcache.IDeleteOpt]) error

Delete provides a mock function with given fields: ctx, key, options

func (*RefreshCache[K, V]) EXPECT 

func (_m *RefreshCache[K, V]) EXPECT() *RefreshCache_Expecter[K, V]

func (*RefreshCache[K, V]) Get 

func (_m *RefreshCache[K, V]) Get(ctx context.Context, key K, options ...trcache.IOption[trcache.IGetOpt]) (V, error)

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

func (*RefreshCache[K, V]) GetOrRefresh 

func (_m *RefreshCache[K, V]) GetOrRefresh(ctx context.Context, key K, options ...trcache.IOption[trcache.IRefreshOpt]) (V, error)

GetOrRefresh provides a mock function with given fields: ctx, key, options

func (*RefreshCache[K, V]) Name 

func (_m *RefreshCache[K, V]) Name() string

Name provides a mock function with given fields:

func (*RefreshCache[K, V]) Set 

func (_m *RefreshCache[K, V]) Set(ctx context.Context, key K, value V, options ...trcache.IOption[trcache.ISetOpt]) error

Set provides a mock function with given fields: ctx, key, value, options

type RefreshCache_Delete_Call 

type RefreshCache_Delete_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*RefreshCache_Delete_Call[K, V]) Return 

func (_c *RefreshCache_Delete_Call[K, V]) Return(_a0 error) *RefreshCache_Delete_Call[K, V]

func (*RefreshCache_Delete_Call[K, V]) Run 

func (_c *RefreshCache_Delete_Call[K, V]) Run(run func(ctx context.Context, key K, options ...trcache.IOption[trcache.IDeleteOpt])) *RefreshCache_Delete_Call[K, V]

func (*RefreshCache_Delete_Call[K, V]) RunAndReturn 

func (_c *RefreshCache_Delete_Call[K, V]) RunAndReturn(run func(context.Context, K, ...trcache.IOption[trcache.IDeleteOpt]) error) *RefreshCache_Delete_Call[K, V]

type RefreshCache_Expecter 

type RefreshCache_Expecter[K comparable, V interface{}] struct {
	// contains filtered or unexported fields
}

func (*RefreshCache_Expecter[K, V]) Delete 

func (_e *RefreshCache_Expecter[K, V]) Delete(ctx interface{}, key interface{}, options ...interface{}) *RefreshCache_Delete_Call[K, V]

Delete is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • options ...trcache.IOption[trcache.IDeleteOpt]

func (*RefreshCache_Expecter[K, V]) Get 

func (_e *RefreshCache_Expecter[K, V]) Get(ctx interface{}, key interface{}, options ...interface{}) *RefreshCache_Get_Call[K, V]

Get is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • options ...trcache.IOption[trcache.IGetOpt]

func (*RefreshCache_Expecter[K, V]) GetOrRefresh 

func (_e *RefreshCache_Expecter[K, V]) GetOrRefresh(ctx interface{}, key interface{}, options ...interface{}) *RefreshCache_GetOrRefresh_Call[K, V]

GetOrRefresh is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • options ...trcache.IOption[trcache.IRefreshOpt]

func (*RefreshCache_Expecter[K, V]) Name 

func (_e *RefreshCache_Expecter[K, V]) Name() *RefreshCache_Name_Call[K, V]

Name is a helper method to define mock.On call

func (*RefreshCache_Expecter[K, V]) Set 

func (_e *RefreshCache_Expecter[K, V]) Set(ctx interface{}, key interface{}, value interface{}, options ...interface{}) *RefreshCache_Set_Call[K, V]

Set is a helper method to define mock.On call

  • ctx context.Context
  • key K
  • value V
  • options ...trcache.IOption[trcache.ISetOpt]

type RefreshCache_GetOrRefresh_Call 

type RefreshCache_GetOrRefresh_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*RefreshCache_GetOrRefresh_Call[K, V]) Return 

func (_c *RefreshCache_GetOrRefresh_Call[K, V]) Return(_a0 V, _a1 error) *RefreshCache_GetOrRefresh_Call[K, V]

func (*RefreshCache_GetOrRefresh_Call[K, V]) Run 

func (_c *RefreshCache_GetOrRefresh_Call[K, V]) Run(run func(ctx context.Context, key K, options ...trcache.IOption[trcache.IRefreshOpt])) *RefreshCache_GetOrRefresh_Call[K, V]

func (*RefreshCache_GetOrRefresh_Call[K, V]) RunAndReturn 

func (_c *RefreshCache_GetOrRefresh_Call[K, V]) RunAndReturn(run func(context.Context, K, ...trcache.IOption[trcache.IRefreshOpt]) (V, error)) *RefreshCache_GetOrRefresh_Call[K, V]

type RefreshCache_Get_Call 

type RefreshCache_Get_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*RefreshCache_Get_Call[K, V]) Return 

func (_c *RefreshCache_Get_Call[K, V]) Return(_a0 V, _a1 error) *RefreshCache_Get_Call[K, V]

func (*RefreshCache_Get_Call[K, V]) Run 

func (_c *RefreshCache_Get_Call[K, V]) Run(run func(ctx context.Context, key K, options ...trcache.IOption[trcache.IGetOpt])) *RefreshCache_Get_Call[K, V]

func (*RefreshCache_Get_Call[K, V]) RunAndReturn 

func (_c *RefreshCache_Get_Call[K, V]) RunAndReturn(run func(context.Context, K, ...trcache.IOption[trcache.IGetOpt]) (V, error)) *RefreshCache_Get_Call[K, V]

type RefreshCache_Name_Call 

type RefreshCache_Name_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*RefreshCache_Name_Call[K, V]) Return 

func (_c *RefreshCache_Name_Call[K, V]) Return(_a0 string) *RefreshCache_Name_Call[K, V]

func (*RefreshCache_Name_Call[K, V]) Run 

func (_c *RefreshCache_Name_Call[K, V]) Run(run func()) *RefreshCache_Name_Call[K, V]

func (*RefreshCache_Name_Call[K, V]) RunAndReturn 

func (_c *RefreshCache_Name_Call[K, V]) RunAndReturn(run func() string) *RefreshCache_Name_Call[K, V]

type RefreshCache_Set_Call 

type RefreshCache_Set_Call[K comparable, V interface{}] struct {
	*mock.Call
}

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

func (*RefreshCache_Set_Call[K, V]) Return 

func (_c *RefreshCache_Set_Call[K, V]) Return(_a0 error) *RefreshCache_Set_Call[K, V]

func (*RefreshCache_Set_Call[K, V]) Run 

func (_c *RefreshCache_Set_Call[K, V]) Run(run func(ctx context.Context, key K, value V, options ...trcache.IOption[trcache.ISetOpt])) *RefreshCache_Set_Call[K, V]

func (*RefreshCache_Set_Call[K, V]) RunAndReturn 

func (_c *RefreshCache_Set_Call[K, V]) RunAndReturn(run func(context.Context, K, V, ...trcache.IOption[trcache.ISetOpt]) error) *RefreshCache_Set_Call[K, V]

type Validator 

type Validator[V interface{}] struct {
	mock.Mock
}

Validator is an autogenerated mock type for the Validator type

func NewValidator 

func NewValidator[V interface{}](t mockConstructorTestingTNewValidator) *Validator[V]

NewValidator creates a new instance of Validator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*Validator[V]) EXPECT 

func (_m *Validator[V]) EXPECT() *Validator_Expecter[V]

func (*Validator[V]) ValidateGet 

func (_m *Validator[V]) ValidateGet(ctx context.Context, data V) error

ValidateGet provides a mock function with given fields: ctx, data

type Validator_Expecter 

type Validator_Expecter[V interface{}] struct {
	// contains filtered or unexported fields
}

func (*Validator_Expecter[V]) ValidateGet 

func (_e *Validator_Expecter[V]) ValidateGet(ctx interface{}, data interface{}) *Validator_ValidateGet_Call[V]

ValidateGet is a helper method to define mock.On call

  • ctx context.Context
  • data V

type Validator_ValidateGet_Call 

type Validator_ValidateGet_Call[V interface{}] struct {
	*mock.Call
}

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

func (*Validator_ValidateGet_Call[V]) Return 

func (_c *Validator_ValidateGet_Call[V]) Return(_a0 error) *Validator_ValidateGet_Call[V]

func (*Validator_ValidateGet_Call[V]) Run 

func (_c *Validator_ValidateGet_Call[V]) Run(run func(ctx context.Context, data V)) *Validator_ValidateGet_Call[V]

func (*Validator_ValidateGet_Call[V]) RunAndReturn 

func (_c *Validator_ValidateGet_Call[V]) RunAndReturn(run func(context.Context, V) error) *Validator_ValidateGet_Call[V]

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.