mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-11-27 04:43:59 +01:00
update redis mock
Signed-off-by: Victoria Nadasdi <victoria@efertone.me>
This commit is contained in:
Victoria Nadasdi
parent
dd6413d350
commit
dd9f885293
1 changed files with 668 additions and 0 deletions
|
|
@ -2058,6 +2058,413 @@ func (mr *MockUniversalClientMockRecorder) FCallRo(arg0, arg1, arg2 any, arg3 ..
|
|||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockUniversalClient)(nil).FCallRo), varargs...)
|
||||
}
|
||||
|
||||
// FTAggregate mocks base method.
|
||||
func (m *MockUniversalClient) FTAggregate(arg0 context.Context, arg1, arg2 string) *redis.MapStringInterfaceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTAggregate", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTAggregate indicates an expected call of FTAggregate.
|
||||
func (mr *MockUniversalClientMockRecorder) FTAggregate(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregate", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregate), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTAggregateWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) FTAggregateWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTAggregateOptions) *redis.AggregateCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTAggregateWithArgs", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.AggregateCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTAggregateWithArgs indicates an expected call of FTAggregateWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) FTAggregateWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregateWithArgs), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTAliasAdd mocks base method.
|
||||
func (m *MockUniversalClient) FTAliasAdd(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTAliasAdd", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTAliasAdd indicates an expected call of FTAliasAdd.
|
||||
func (mr *MockUniversalClientMockRecorder) FTAliasAdd(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasAdd), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTAliasDel mocks base method.
|
||||
func (m *MockUniversalClient) FTAliasDel(arg0 context.Context, arg1 string) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTAliasDel", arg0, arg1)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTAliasDel indicates an expected call of FTAliasDel.
|
||||
func (mr *MockUniversalClientMockRecorder) FTAliasDel(arg0, arg1 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasDel", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasDel), arg0, arg1)
|
||||
}
|
||||
|
||||
// FTAliasUpdate mocks base method.
|
||||
func (m *MockUniversalClient) FTAliasUpdate(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTAliasUpdate", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTAliasUpdate indicates an expected call of FTAliasUpdate.
|
||||
func (mr *MockUniversalClientMockRecorder) FTAliasUpdate(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasUpdate), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTAlter mocks base method.
|
||||
func (m *MockUniversalClient) FTAlter(arg0 context.Context, arg1 string, arg2 bool, arg3 []any) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTAlter", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTAlter indicates an expected call of FTAlter.
|
||||
func (mr *MockUniversalClientMockRecorder) FTAlter(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAlter", reflect.TypeOf((*MockUniversalClient)(nil).FTAlter), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTConfigGet mocks base method.
|
||||
func (m *MockUniversalClient) FTConfigGet(arg0 context.Context, arg1 string) *redis.MapMapStringInterfaceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTConfigGet", arg0, arg1)
|
||||
ret0, _ := ret[0].(*redis.MapMapStringInterfaceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTConfigGet indicates an expected call of FTConfigGet.
|
||||
func (mr *MockUniversalClientMockRecorder) FTConfigGet(arg0, arg1 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigGet), arg0, arg1)
|
||||
}
|
||||
|
||||
// FTConfigSet mocks base method.
|
||||
func (m *MockUniversalClient) FTConfigSet(arg0 context.Context, arg1 string, arg2 any) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTConfigSet", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTConfigSet indicates an expected call of FTConfigSet.
|
||||
func (mr *MockUniversalClientMockRecorder) FTConfigSet(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigSet), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTCreate mocks base method.
|
||||
func (m *MockUniversalClient) FTCreate(arg0 context.Context, arg1 string, arg2 *redis.FTCreateOptions, arg3 ...*redis.FieldSchema) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2}
|
||||
for _, a := range arg3 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "FTCreate", varargs...)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTCreate indicates an expected call of FTCreate.
|
||||
func (mr *MockUniversalClientMockRecorder) FTCreate(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2}, arg3...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCreate", reflect.TypeOf((*MockUniversalClient)(nil).FTCreate), varargs...)
|
||||
}
|
||||
|
||||
// FTCursorDel mocks base method.
|
||||
func (m *MockUniversalClient) FTCursorDel(arg0 context.Context, arg1 string, arg2 int) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTCursorDel", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTCursorDel indicates an expected call of FTCursorDel.
|
||||
func (mr *MockUniversalClientMockRecorder) FTCursorDel(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorDel", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorDel), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTCursorRead mocks base method.
|
||||
func (m *MockUniversalClient) FTCursorRead(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.MapStringInterfaceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTCursorRead", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTCursorRead indicates an expected call of FTCursorRead.
|
||||
func (mr *MockUniversalClientMockRecorder) FTCursorRead(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorRead", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorRead), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTDictAdd mocks base method.
|
||||
func (m *MockUniversalClient) FTDictAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "FTDictAdd", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTDictAdd indicates an expected call of FTDictAdd.
|
||||
func (mr *MockUniversalClientMockRecorder) FTDictAdd(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTDictAdd), varargs...)
|
||||
}
|
||||
|
||||
// FTDictDel mocks base method.
|
||||
func (m *MockUniversalClient) FTDictDel(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "FTDictDel", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTDictDel indicates an expected call of FTDictDel.
|
||||
func (mr *MockUniversalClientMockRecorder) FTDictDel(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDel", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDel), varargs...)
|
||||
}
|
||||
|
||||
// FTDictDump mocks base method.
|
||||
func (m *MockUniversalClient) FTDictDump(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTDictDump", arg0, arg1)
|
||||
ret0, _ := ret[0].(*redis.StringSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTDictDump indicates an expected call of FTDictDump.
|
||||
func (mr *MockUniversalClientMockRecorder) FTDictDump(arg0, arg1 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDump", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDump), arg0, arg1)
|
||||
}
|
||||
|
||||
// FTDropIndex mocks base method.
|
||||
func (m *MockUniversalClient) FTDropIndex(arg0 context.Context, arg1 string) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTDropIndex", arg0, arg1)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTDropIndex indicates an expected call of FTDropIndex.
|
||||
func (mr *MockUniversalClientMockRecorder) FTDropIndex(arg0, arg1 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndex", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndex), arg0, arg1)
|
||||
}
|
||||
|
||||
// FTDropIndexWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) FTDropIndexWithArgs(arg0 context.Context, arg1 string, arg2 *redis.FTDropIndexOptions) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTDropIndexWithArgs", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTDropIndexWithArgs indicates an expected call of FTDropIndexWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) FTDropIndexWithArgs(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndexWithArgs), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTExplain mocks base method.
|
||||
func (m *MockUniversalClient) FTExplain(arg0 context.Context, arg1, arg2 string) *redis.StringCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTExplain", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StringCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTExplain indicates an expected call of FTExplain.
|
||||
func (mr *MockUniversalClientMockRecorder) FTExplain(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplain", reflect.TypeOf((*MockUniversalClient)(nil).FTExplain), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTExplainWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) FTExplainWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTExplainOptions) *redis.StringCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTExplainWithArgs", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.StringCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTExplainWithArgs indicates an expected call of FTExplainWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) FTExplainWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplainWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTExplainWithArgs), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTInfo mocks base method.
|
||||
func (m *MockUniversalClient) FTInfo(arg0 context.Context, arg1 string) *redis.FTInfoCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTInfo", arg0, arg1)
|
||||
ret0, _ := ret[0].(*redis.FTInfoCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTInfo indicates an expected call of FTInfo.
|
||||
func (mr *MockUniversalClientMockRecorder) FTInfo(arg0, arg1 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTInfo", reflect.TypeOf((*MockUniversalClient)(nil).FTInfo), arg0, arg1)
|
||||
}
|
||||
|
||||
// FTSearch mocks base method.
|
||||
func (m *MockUniversalClient) FTSearch(arg0 context.Context, arg1, arg2 string) *redis.FTSearchCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSearch", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.FTSearchCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSearch indicates an expected call of FTSearch.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSearch(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearch", reflect.TypeOf((*MockUniversalClient)(nil).FTSearch), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTSearchWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) FTSearchWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTSearchOptions) *redis.FTSearchCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSearchWithArgs", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.FTSearchCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSearchWithArgs indicates an expected call of FTSearchWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSearchWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearchWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSearchWithArgs), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTSpellCheck mocks base method.
|
||||
func (m *MockUniversalClient) FTSpellCheck(arg0 context.Context, arg1, arg2 string) *redis.FTSpellCheckCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSpellCheck", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.FTSpellCheckCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSpellCheck indicates an expected call of FTSpellCheck.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSpellCheck(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheck", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheck), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FTSpellCheckWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) FTSpellCheckWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSpellCheckWithArgs", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.FTSpellCheckCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSpellCheckWithArgs indicates an expected call of FTSpellCheckWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSpellCheckWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheckWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheckWithArgs), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTSynDump mocks base method.
|
||||
func (m *MockUniversalClient) FTSynDump(arg0 context.Context, arg1 string) *redis.FTSynDumpCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSynDump", arg0, arg1)
|
||||
ret0, _ := ret[0].(*redis.FTSynDumpCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSynDump indicates an expected call of FTSynDump.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSynDump(arg0, arg1 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynDump", reflect.TypeOf((*MockUniversalClient)(nil).FTSynDump), arg0, arg1)
|
||||
}
|
||||
|
||||
// FTSynUpdate mocks base method.
|
||||
func (m *MockUniversalClient) FTSynUpdate(arg0 context.Context, arg1 string, arg2 any, arg3 []any) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSynUpdate", arg0, arg1, arg2, arg3)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSynUpdate indicates an expected call of FTSynUpdate.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSynUpdate(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdate), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// FTSynUpdateWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) FTSynUpdateWithArgs(arg0 context.Context, arg1 string, arg2 any, arg3 *redis.FTSynUpdateOptions, arg4 []any) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTSynUpdateWithArgs", arg0, arg1, arg2, arg3, arg4)
|
||||
ret0, _ := ret[0].(*redis.StatusCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTSynUpdateWithArgs indicates an expected call of FTSynUpdateWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) FTSynUpdateWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdateWithArgs), arg0, arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
// FTTagVals mocks base method.
|
||||
func (m *MockUniversalClient) FTTagVals(arg0 context.Context, arg1, arg2 string) *redis.StringSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FTTagVals", arg0, arg1, arg2)
|
||||
ret0, _ := ret[0].(*redis.StringSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FTTagVals indicates an expected call of FTTagVals.
|
||||
func (mr *MockUniversalClientMockRecorder) FTTagVals(arg0, arg1, arg2 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTTagVals", reflect.TypeOf((*MockUniversalClient)(nil).FTTagVals), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// FT_List mocks base method.
|
||||
func (m *MockUniversalClient) FT_List(arg0 context.Context) *redis.StringSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "FT_List", arg0)
|
||||
ret0, _ := ret[0].(*redis.StringSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// FT_List indicates an expected call of FT_List.
|
||||
func (mr *MockUniversalClientMockRecorder) FT_List(arg0 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FT_List", reflect.TypeOf((*MockUniversalClient)(nil).FT_List), arg0)
|
||||
}
|
||||
|
||||
// FlushAll mocks base method.
|
||||
func (m *MockUniversalClient) FlushAll(arg0 context.Context) *redis.StatusCmd {
|
||||
m.ctrl.T.Helper()
|
||||
|
|
@ -2540,6 +2947,101 @@ func (mr *MockUniversalClientMockRecorder) HExists(arg0, arg1, arg2 any) *gomock
|
|||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockUniversalClient)(nil).HExists), arg0, arg1, arg2)
|
||||
}
|
||||
|
||||
// HExpire mocks base method.
|
||||
func (m *MockUniversalClient) HExpire(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2}
|
||||
for _, a := range arg3 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HExpire", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HExpire indicates an expected call of HExpire.
|
||||
func (mr *MockUniversalClientMockRecorder) HExpire(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2}, arg3...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpire", reflect.TypeOf((*MockUniversalClient)(nil).HExpire), varargs...)
|
||||
}
|
||||
|
||||
// HExpireAt mocks base method.
|
||||
func (m *MockUniversalClient) HExpireAt(arg0 context.Context, arg1 string, arg2 time.Time, arg3 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2}
|
||||
for _, a := range arg3 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HExpireAt", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HExpireAt indicates an expected call of HExpireAt.
|
||||
func (mr *MockUniversalClientMockRecorder) HExpireAt(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2}, arg3...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAt), varargs...)
|
||||
}
|
||||
|
||||
// HExpireAtWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) HExpireAtWithArgs(arg0 context.Context, arg1 string, arg2 time.Time, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2, arg3}
|
||||
for _, a := range arg4 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HExpireAtWithArgs", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HExpireAtWithArgs indicates an expected call of HExpireAtWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) HExpireAtWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAtWithArgs), varargs...)
|
||||
}
|
||||
|
||||
// HExpireTime mocks base method.
|
||||
func (m *MockUniversalClient) HExpireTime(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HExpireTime", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HExpireTime indicates an expected call of HExpireTime.
|
||||
func (mr *MockUniversalClientMockRecorder) HExpireTime(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HExpireTime), varargs...)
|
||||
}
|
||||
|
||||
// HExpireWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) HExpireWithArgs(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2, arg3}
|
||||
for _, a := range arg4 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HExpireWithArgs", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HExpireWithArgs indicates an expected call of HExpireWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) HExpireWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireWithArgs), varargs...)
|
||||
}
|
||||
|
||||
// HGet mocks base method.
|
||||
func (m *MockUniversalClient) HGet(arg0 context.Context, arg1, arg2 string) *redis.StringCmd {
|
||||
m.ctrl.T.Helper()
|
||||
|
|
@ -2662,6 +3164,139 @@ func (mr *MockUniversalClientMockRecorder) HMSet(arg0, arg1 any, arg2 ...any) *g
|
|||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockUniversalClient)(nil).HMSet), varargs...)
|
||||
}
|
||||
|
||||
// HPExpire mocks base method.
|
||||
func (m *MockUniversalClient) HPExpire(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2}
|
||||
for _, a := range arg3 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPExpire", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPExpire indicates an expected call of HPExpire.
|
||||
func (mr *MockUniversalClientMockRecorder) HPExpire(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2}, arg3...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpire", reflect.TypeOf((*MockUniversalClient)(nil).HPExpire), varargs...)
|
||||
}
|
||||
|
||||
// HPExpireAt mocks base method.
|
||||
func (m *MockUniversalClient) HPExpireAt(arg0 context.Context, arg1 string, arg2 time.Time, arg3 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2}
|
||||
for _, a := range arg3 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPExpireAt", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPExpireAt indicates an expected call of HPExpireAt.
|
||||
func (mr *MockUniversalClientMockRecorder) HPExpireAt(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2}, arg3...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAt), varargs...)
|
||||
}
|
||||
|
||||
// HPExpireAtWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) HPExpireAtWithArgs(arg0 context.Context, arg1 string, arg2 time.Time, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2, arg3}
|
||||
for _, a := range arg4 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPExpireAtWithArgs", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPExpireAtWithArgs indicates an expected call of HPExpireAtWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) HPExpireAtWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAtWithArgs), varargs...)
|
||||
}
|
||||
|
||||
// HPExpireTime mocks base method.
|
||||
func (m *MockUniversalClient) HPExpireTime(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPExpireTime", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPExpireTime indicates an expected call of HPExpireTime.
|
||||
func (mr *MockUniversalClientMockRecorder) HPExpireTime(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireTime), varargs...)
|
||||
}
|
||||
|
||||
// HPExpireWithArgs mocks base method.
|
||||
func (m *MockUniversalClient) HPExpireWithArgs(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1, arg2, arg3}
|
||||
for _, a := range arg4 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPExpireWithArgs", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPExpireWithArgs indicates an expected call of HPExpireWithArgs.
|
||||
func (mr *MockUniversalClientMockRecorder) HPExpireWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireWithArgs), varargs...)
|
||||
}
|
||||
|
||||
// HPTTL mocks base method.
|
||||
func (m *MockUniversalClient) HPTTL(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPTTL", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPTTL indicates an expected call of HPTTL.
|
||||
func (mr *MockUniversalClientMockRecorder) HPTTL(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPTTL", reflect.TypeOf((*MockUniversalClient)(nil).HPTTL), varargs...)
|
||||
}
|
||||
|
||||
// HPersist mocks base method.
|
||||
func (m *MockUniversalClient) HPersist(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HPersist", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HPersist indicates an expected call of HPersist.
|
||||
func (mr *MockUniversalClientMockRecorder) HPersist(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPersist", reflect.TypeOf((*MockUniversalClient)(nil).HPersist), varargs...)
|
||||
}
|
||||
|
||||
// HRandField mocks base method.
|
||||
func (m *MockUniversalClient) HRandField(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
|
|
@ -2704,6 +3339,20 @@ func (mr *MockUniversalClientMockRecorder) HScan(arg0, arg1, arg2, arg3, arg4 an
|
|||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockUniversalClient)(nil).HScan), arg0, arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
// HScanNoValues mocks base method.
|
||||
func (m *MockUniversalClient) HScanNoValues(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "HScanNoValues", arg0, arg1, arg2, arg3, arg4)
|
||||
ret0, _ := ret[0].(*redis.ScanCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HScanNoValues indicates an expected call of HScanNoValues.
|
||||
func (mr *MockUniversalClientMockRecorder) HScanNoValues(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScanNoValues", reflect.TypeOf((*MockUniversalClient)(nil).HScanNoValues), arg0, arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
// HSet mocks base method.
|
||||
func (m *MockUniversalClient) HSet(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
|
||||
m.ctrl.T.Helper()
|
||||
|
|
@ -2737,6 +3386,25 @@ func (mr *MockUniversalClientMockRecorder) HSetNX(arg0, arg1, arg2, arg3 any) *g
|
|||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockUniversalClient)(nil).HSetNX), arg0, arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
// HTTL mocks base method.
|
||||
func (m *MockUniversalClient) HTTL(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []any{arg0, arg1}
|
||||
for _, a := range arg2 {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "HTTL", varargs...)
|
||||
ret0, _ := ret[0].(*redis.IntSliceCmd)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// HTTL indicates an expected call of HTTL.
|
||||
func (mr *MockUniversalClientMockRecorder) HTTL(arg0, arg1 any, arg2 ...any) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]any{arg0, arg1}, arg2...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTL", reflect.TypeOf((*MockUniversalClient)(nil).HTTL), varargs...)
|
||||
}
|
||||
|
||||
// HVals mocks base method.
|
||||
func (m *MockUniversalClient) HVals(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
|
||||
m.ctrl.T.Helper()
|
||||
|
|
|
|||
Loading…
Reference in a new issue