proxy-common/cache/mock/cache.go

// Code generated by MockGen. DO NOT EDIT.
// Source: interfaces.go
//
// Generated by this command:
//
//	mockgen -package=mock -source=interfaces.go -destination=mock/cache.go
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	redis "github.com/go-redis/redis/v8"
	models "github.com/status-im/proxy-common/models"
	gomock "go.uber.org/mock/gomock"
)

// MockCache is a mock of Cache interface.
type MockCache struct {
	ctrl     *gomock.Controller
	recorder *MockCacheMockRecorder
	isgomock struct{}
}

// MockCacheMockRecorder is the mock recorder for MockCache.
type MockCacheMockRecorder struct {
	mock *MockCache
}

// NewMockCache creates a new mock instance.
func NewMockCache(ctrl *gomock.Controller) *MockCache {
	mock := &MockCache{ctrl: ctrl}
	mock.recorder = &MockCacheMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockCache) Delete(key string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Delete", key)
}

// Delete indicates an expected call of Delete.
func (mr *MockCacheMockRecorder) Delete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCache)(nil).Delete), key)
}

// Get mocks base method.
func (m *MockCache) Get(key string) (*models.CacheEntry, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(*models.CacheEntry)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockCacheMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCache)(nil).Get), key)
}

// GetStale mocks base method.
func (m *MockCache) GetStale(key string) (*models.CacheEntry, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStale", key)
	ret0, _ := ret[0].(*models.CacheEntry)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStale indicates an expected call of GetStale.
func (mr *MockCacheMockRecorder) GetStale(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStale", reflect.TypeOf((*MockCache)(nil).GetStale), key)
}

// Set mocks base method.
func (m *MockCache) Set(key string, val []byte, ttl models.TTL) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Set", key, val, ttl)
}

// Set indicates an expected call of Set.
func (mr *MockCacheMockRecorder) Set(key, val, ttl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), key, val, ttl)
}

// MockLevelAwareCache is a mock of LevelAwareCache interface.
type MockLevelAwareCache struct {
	ctrl     *gomock.Controller
	recorder *MockLevelAwareCacheMockRecorder
	isgomock struct{}
}

// MockLevelAwareCacheMockRecorder is the mock recorder for MockLevelAwareCache.
type MockLevelAwareCacheMockRecorder struct {
	mock *MockLevelAwareCache
}

// NewMockLevelAwareCache creates a new mock instance.
func NewMockLevelAwareCache(ctrl *gomock.Controller) *MockLevelAwareCache {
	mock := &MockLevelAwareCache{ctrl: ctrl}
	mock.recorder = &MockLevelAwareCacheMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockLevelAwareCache) Delete(key string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Delete", key)
}

// Delete indicates an expected call of Delete.
func (mr *MockLevelAwareCacheMockRecorder) Delete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLevelAwareCache)(nil).Delete), key)
}

// Get mocks base method.
func (m *MockLevelAwareCache) Get(key string) (*models.CacheEntry, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(*models.CacheEntry)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLevelAwareCacheMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLevelAwareCache)(nil).Get), key)
}

// GetStale mocks base method.
func (m *MockLevelAwareCache) GetStale(key string) (*models.CacheEntry, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStale", key)
	ret0, _ := ret[0].(*models.CacheEntry)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStale indicates an expected call of GetStale.
func (mr *MockLevelAwareCacheMockRecorder) GetStale(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStale", reflect.TypeOf((*MockLevelAwareCache)(nil).GetStale), key)
}

// GetStaleWithLevel mocks base method.
func (m *MockLevelAwareCache) GetStaleWithLevel(key string) *models.CacheResult {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStaleWithLevel", key)
	ret0, _ := ret[0].(*models.CacheResult)
	return ret0
}

// GetStaleWithLevel indicates an expected call of GetStaleWithLevel.
func (mr *MockLevelAwareCacheMockRecorder) GetStaleWithLevel(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaleWithLevel", reflect.TypeOf((*MockLevelAwareCache)(nil).GetStaleWithLevel), key)
}

// GetWithLevel mocks base method.
func (m *MockLevelAwareCache) GetWithLevel(key string) *models.CacheResult {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWithLevel", key)
	ret0, _ := ret[0].(*models.CacheResult)
	return ret0
}

// GetWithLevel indicates an expected call of GetWithLevel.
func (mr *MockLevelAwareCacheMockRecorder) GetWithLevel(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWithLevel", reflect.TypeOf((*MockLevelAwareCache)(nil).GetWithLevel), key)
}

// Set mocks base method.
func (m *MockLevelAwareCache) Set(key string, val []byte, ttl models.TTL) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Set", key, val, ttl)
}

// Set indicates an expected call of Set.
func (mr *MockLevelAwareCacheMockRecorder) Set(key, val, ttl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockLevelAwareCache)(nil).Set), key, val, ttl)
}

// MockKeyDbClient is a mock of KeyDbClient interface.
type MockKeyDbClient struct {
	ctrl     *gomock.Controller
	recorder *MockKeyDbClientMockRecorder
	isgomock struct{}
}

// MockKeyDbClientMockRecorder is the mock recorder for MockKeyDbClient.
type MockKeyDbClientMockRecorder struct {
	mock *MockKeyDbClient
}

// NewMockKeyDbClient creates a new mock instance.
func NewMockKeyDbClient(ctrl *gomock.Controller) *MockKeyDbClient {
	mock := &MockKeyDbClient{ctrl: ctrl}
	mock.recorder = &MockKeyDbClientMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of Close.
func (mr *MockKeyDbClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockKeyDbClient)(nil).Close))
}

// Del mocks base method.
func (m *MockKeyDbClient) Del(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Del", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Del indicates an expected call of Del.
func (mr *MockKeyDbClientMockRecorder) Del(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockKeyDbClient)(nil).Del), varargs...)
}

// Get mocks base method.
func (m *MockKeyDbClient) Get(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockKeyDbClientMockRecorder) Get(ctx, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockKeyDbClient)(nil).Get), ctx, key)
}

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

// Ping indicates an expected call of Ping.
func (mr *MockKeyDbClientMockRecorder) Ping(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockKeyDbClient)(nil).Ping), ctx)
}

// Set mocks base method.
func (m *MockKeyDbClient) Set(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockKeyDbClientMockRecorder) Set(ctx, key, value, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockKeyDbClient)(nil).Set), ctx, key, value, expiration)
}

// MockLogger is a mock of Logger interface.
type MockLogger struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerMockRecorder
	isgomock struct{}
}

// MockLoggerMockRecorder is the mock recorder for MockLogger.
type MockLoggerMockRecorder struct {
	mock *MockLogger
}

// NewMockLogger creates a new mock instance.
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
	mock := &MockLogger{ctrl: ctrl}
	mock.recorder = &MockLoggerMockRecorder{mock}
	return mock
}

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

// Debug mocks base method.
func (m *MockLogger) Debug(msg string, keysAndValues ...any) {
	m.ctrl.T.Helper()
	varargs := []any{msg}
	for _, a := range keysAndValues {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debug", varargs...)
}

// Debug indicates an expected call of Debug.
func (mr *MockLoggerMockRecorder) Debug(msg any, keysAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{msg}, keysAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), varargs...)
}

// Error mocks base method.
func (m *MockLogger) Error(msg string, keysAndValues ...any) {
	m.ctrl.T.Helper()
	varargs := []any{msg}
	for _, a := range keysAndValues {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

// Error indicates an expected call of Error.
func (mr *MockLoggerMockRecorder) Error(msg any, keysAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{msg}, keysAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), varargs...)
}

// Info mocks base method.
func (m *MockLogger) Info(msg string, keysAndValues ...any) {
	m.ctrl.T.Helper()
	varargs := []any{msg}
	for _, a := range keysAndValues {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Info", varargs...)
}

// Info indicates an expected call of Info.
func (mr *MockLoggerMockRecorder) Info(msg any, keysAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{msg}, keysAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), varargs...)
}

// Warn mocks base method.
func (m *MockLogger) Warn(msg string, keysAndValues ...any) {
	m.ctrl.T.Helper()
	varargs := []any{msg}
	for _, a := range keysAndValues {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warn", varargs...)
}

// Warn indicates an expected call of Warn.
func (mr *MockLoggerMockRecorder) Warn(msg any, keysAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{msg}, keysAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), varargs...)
}

// MockMetricsRecorder is a mock of MetricsRecorder interface.
type MockMetricsRecorder struct {
	ctrl     *gomock.Controller
	recorder *MockMetricsRecorderMockRecorder
	isgomock struct{}
}

// MockMetricsRecorderMockRecorder is the mock recorder for MockMetricsRecorder.
type MockMetricsRecorderMockRecorder struct {
	mock *MockMetricsRecorder
}

// NewMockMetricsRecorder creates a new mock instance.
func NewMockMetricsRecorder(ctrl *gomock.Controller) *MockMetricsRecorder {
	mock := &MockMetricsRecorder{ctrl: ctrl}
	mock.recorder = &MockMetricsRecorderMockRecorder{mock}
	return mock
}

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

// RecordCacheBytesRead mocks base method.
func (m *MockMetricsRecorder) RecordCacheBytesRead(level, cacheType, chain, network string, bytesRead int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordCacheBytesRead", level, cacheType, chain, network, bytesRead)
}

// RecordCacheBytesRead indicates an expected call of RecordCacheBytesRead.
func (mr *MockMetricsRecorderMockRecorder) RecordCacheBytesRead(level, cacheType, chain, network, bytesRead any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordCacheBytesRead", reflect.TypeOf((*MockMetricsRecorder)(nil).RecordCacheBytesRead), level, cacheType, chain, network, bytesRead)
}

// RecordCacheError mocks base method.
func (m *MockMetricsRecorder) RecordCacheError(level, kind string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordCacheError", level, kind)
}

// RecordCacheError indicates an expected call of RecordCacheError.
func (mr *MockMetricsRecorderMockRecorder) RecordCacheError(level, kind any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordCacheError", reflect.TypeOf((*MockMetricsRecorder)(nil).RecordCacheError), level, kind)
}

// RecordCacheHit mocks base method.
func (m *MockMetricsRecorder) RecordCacheHit(cacheType, level, chain, network, rpcMethod string, itemAge time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordCacheHit", cacheType, level, chain, network, rpcMethod, itemAge)
}

// RecordCacheHit indicates an expected call of RecordCacheHit.
func (mr *MockMetricsRecorderMockRecorder) RecordCacheHit(cacheType, level, chain, network, rpcMethod, itemAge any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordCacheHit", reflect.TypeOf((*MockMetricsRecorder)(nil).RecordCacheHit), cacheType, level, chain, network, rpcMethod, itemAge)
}

// RecordCacheMiss mocks base method.
func (m *MockMetricsRecorder) RecordCacheMiss(cacheType, chain, network, rpcMethod string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordCacheMiss", cacheType, chain, network, rpcMethod)
}

// RecordCacheMiss indicates an expected call of RecordCacheMiss.
func (mr *MockMetricsRecorderMockRecorder) RecordCacheMiss(cacheType, chain, network, rpcMethod any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordCacheMiss", reflect.TypeOf((*MockMetricsRecorder)(nil).RecordCacheMiss), cacheType, chain, network, rpcMethod)
}

// RecordCacheSet mocks base method.
func (m *MockMetricsRecorder) RecordCacheSet(level, cacheType, chain, network string, dataSize int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordCacheSet", level, cacheType, chain, network, dataSize)
}

// RecordCacheSet indicates an expected call of RecordCacheSet.
func (mr *MockMetricsRecorderMockRecorder) RecordCacheSet(level, cacheType, chain, network, dataSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordCacheSet", reflect.TypeOf((*MockMetricsRecorder)(nil).RecordCacheSet), level, cacheType, chain, network, dataSize)
}

// TimeCacheOperation mocks base method.
func (m *MockMetricsRecorder) TimeCacheOperation(operation, level string) func() {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimeCacheOperation", operation, level)
	ret0, _ := ret[0].(func())
	return ret0
}

// TimeCacheOperation indicates an expected call of TimeCacheOperation.
func (mr *MockMetricsRecorderMockRecorder) TimeCacheOperation(operation, level any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeCacheOperation", reflect.TypeOf((*MockMetricsRecorder)(nil).TimeCacheOperation), operation, level)
}

// UpdateCacheKeys mocks base method.
func (m *MockMetricsRecorder) UpdateCacheKeys(level string, count int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateCacheKeys", level, count)
}

// UpdateCacheKeys indicates an expected call of UpdateCacheKeys.
func (mr *MockMetricsRecorderMockRecorder) UpdateCacheKeys(level, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCacheKeys", reflect.TypeOf((*MockMetricsRecorder)(nil).UpdateCacheKeys), level, count)
}

// UpdateL1CacheCapacity mocks base method.
func (m *MockMetricsRecorder) UpdateL1CacheCapacity(capacity, used int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateL1CacheCapacity", capacity, used)
}

// UpdateL1CacheCapacity indicates an expected call of UpdateL1CacheCapacity.
func (mr *MockMetricsRecorderMockRecorder) UpdateL1CacheCapacity(capacity, used any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateL1CacheCapacity", reflect.TypeOf((*MockMetricsRecorder)(nil).UpdateL1CacheCapacity), capacity, used)
}