rancher/steve
1
0
Fork 0
mirror of https://github.com/rancher/steve.git synced 2025-09-08 18:59:58 +00:00
Code Issues Projects Releases Wiki Activity

Bumped dependencies to be compatible with k8s-v1.33 (#681)

Browse Source 
Signed-off-by: swastik959 <Sswastik959@gmail.com>
This commit is contained in:
Swastik Gour
2025-06-20 17:53:42 +05:30
committed by GitHub
parent c32995dba4
commit e17ca28461
30 changed files with 927 additions and 833 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
pkg/sqlcache/store/db_mocks_test.go
View File

@@ -23,6 +23,7 @@ import (
type MockRows struct {
ctrl *gomock.Controller
recorder *MockRowsMockRecorder
isgomock struct{}
}
// MockRowsMockRecorder is the mock recorder for MockRows.
@@ -85,10 +86,10 @@ func (mr *MockRowsMockRecorder) Next() *gomock.Call {
}
// Scan mocks base method.
func (m *MockRows) Scan(arg0 ...any) error {
func (m *MockRows) Scan(dest ...any) error {
m.ctrl.T.Helper()
varargs := []any{}
for _, a := range arg0 {
for _, a := range dest {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Scan", varargs...)
@@ -97,15 +98,16 @@ func (m *MockRows) Scan(arg0 ...any) error {
}
// Scan indicates an expected call of Scan.
func (mr *MockRowsMockRecorder) Scan(arg0 ...any) *gomock.Call {
func (mr *MockRowsMockRecorder) Scan(dest ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockRows)(nil).Scan), arg0...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockRows)(nil).Scan), dest...)
}
// MockClient is a mock of Client interface.
type MockClient struct {
ctrl *gomock.Controller
recorder *MockClientMockRecorder
isgomock struct{}
}
// MockClientMockRecorder is the mock recorder for MockClient.
@@ -126,53 +128,53 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder {
}
// CloseStmt mocks base method.
func (m *MockClient) CloseStmt(arg0 db.Closable) error {
func (m *MockClient) CloseStmt(closable db.Closable) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseStmt", arg0)
ret := m.ctrl.Call(m, "CloseStmt", closable)
ret0, _ := ret[0].(error)
return ret0
}
// CloseStmt indicates an expected call of CloseStmt.
func (mr *MockClientMockRecorder) CloseStmt(arg0 any) *gomock.Call {
func (mr *MockClientMockRecorder) CloseStmt(closable any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseStmt", reflect.TypeOf((*MockClient)(nil).CloseStmt), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseStmt", reflect.TypeOf((*MockClient)(nil).CloseStmt), closable)
}
// NewConnection mocks base method.
func (m *MockClient) NewConnection(arg0 bool) (string, error) {
func (m *MockClient) NewConnection(isTemp bool) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NewConnection", arg0)
ret := m.ctrl.Call(m, "NewConnection", isTemp)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// NewConnection indicates an expected call of NewConnection.
func (mr *MockClientMockRecorder) NewConnection(arg0 any) *gomock.Call {
func (mr *MockClientMockRecorder) NewConnection(isTemp any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnection", reflect.TypeOf((*MockClient)(nil).NewConnection), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnection", reflect.TypeOf((*MockClient)(nil).NewConnection), isTemp)
}
// Prepare mocks base method.
func (m *MockClient) Prepare(arg0 string) *sql.Stmt {
func (m *MockClient) Prepare(stmt string) *sql.Stmt {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Prepare", arg0)
ret := m.ctrl.Call(m, "Prepare", stmt)
ret0, _ := ret[0].(*sql.Stmt)
return ret0
}
// Prepare indicates an expected call of Prepare.
func (mr *MockClientMockRecorder) Prepare(arg0 any) *gomock.Call {
func (mr *MockClientMockRecorder) Prepare(stmt any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockClient)(nil).Prepare), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockClient)(nil).Prepare), stmt)
}
// QueryForRows mocks base method.
func (m *MockClient) QueryForRows(arg0 context.Context, arg1 transaction.Stmt, arg2 ...any) (*sql.Rows, error) {
func (m *MockClient) QueryForRows(ctx context.Context, stmt transaction.Stmt, params ...any) (*sql.Rows, error) {
m.ctrl.T.Helper()
varargs := []any{arg0, arg1}
for _, a := range arg2 {
varargs := []any{ctx, stmt}
for _, a := range params {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "QueryForRows", varargs...)
@@ -182,81 +184,81 @@ func (m *MockClient) QueryForRows(arg0 context.Context, arg1 transaction.Stmt, a
}
// QueryForRows indicates an expected call of QueryForRows.
func (mr *MockClientMockRecorder) QueryForRows(arg0, arg1 any, arg2 ...any) *gomock.Call {
func (mr *MockClientMockRecorder) QueryForRows(ctx, stmt any, params ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0, arg1}, arg2...)
varargs := append([]any{ctx, stmt}, params...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryForRows", reflect.TypeOf((*MockClient)(nil).QueryForRows), varargs...)
}
// ReadInt mocks base method.
func (m *MockClient) ReadInt(arg0 db.Rows) (int, error) {
func (m *MockClient) ReadInt(rows db.Rows) (int, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReadInt", arg0)
ret := m.ctrl.Call(m, "ReadInt", rows)
ret0, _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReadInt indicates an expected call of ReadInt.
func (mr *MockClientMockRecorder) ReadInt(arg0 any) *gomock.Call {
func (mr *MockClientMockRecorder) ReadInt(rows any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadInt", reflect.TypeOf((*MockClient)(nil).ReadInt), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadInt", reflect.TypeOf((*MockClient)(nil).ReadInt), rows)
}
// ReadObjects mocks base method.
func (m *MockClient) ReadObjects(arg0 db.Rows, arg1 reflect.Type, arg2 bool) ([]any, error) {
func (m *MockClient) ReadObjects(rows db.Rows, typ reflect.Type, shouldDecrypt bool) ([]any, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReadObjects", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "ReadObjects", rows, typ, shouldDecrypt)
ret0, _ := ret[0].([]any)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReadObjects indicates an expected call of ReadObjects.
func (mr *MockClientMockRecorder) ReadObjects(arg0, arg1, arg2 any) *gomock.Call {
func (mr *MockClientMockRecorder) ReadObjects(rows, typ, shouldDecrypt any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadObjects", reflect.TypeOf((*MockClient)(nil).ReadObjects), arg0, arg1, arg2)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadObjects", reflect.TypeOf((*MockClient)(nil).ReadObjects), rows, typ, shouldDecrypt)
}
// ReadStrings mocks base method.
func (m *MockClient) ReadStrings(arg0 db.Rows) ([]string, error) {
func (m *MockClient) ReadStrings(rows db.Rows) ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReadStrings", arg0)
ret := m.ctrl.Call(m, "ReadStrings", rows)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReadStrings indicates an expected call of ReadStrings.
func (mr *MockClientMockRecorder) ReadStrings(arg0 any) *gomock.Call {
func (mr *MockClientMockRecorder) ReadStrings(rows any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStrings", reflect.TypeOf((*MockClient)(nil).ReadStrings), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStrings", reflect.TypeOf((*MockClient)(nil).ReadStrings), rows)
}
// Upsert mocks base method.
func (m *MockClient) Upsert(arg0 transaction.Client, arg1 *sql.Stmt, arg2 string, arg3 any, arg4 bool) error {
func (m *MockClient) Upsert(tx transaction.Client, stmt *sql.Stmt, key string, obj any, shouldEncrypt bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Upsert", arg0, arg1, arg2, arg3, arg4)
ret := m.ctrl.Call(m, "Upsert", tx, stmt, key, obj, shouldEncrypt)
ret0, _ := ret[0].(error)
return ret0
}
// Upsert indicates an expected call of Upsert.
func (mr *MockClientMockRecorder) Upsert(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
func (mr *MockClientMockRecorder) Upsert(tx, stmt, key, obj, shouldEncrypt any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upsert", reflect.TypeOf((*MockClient)(nil).Upsert), arg0, arg1, arg2, arg3, arg4)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upsert", reflect.TypeOf((*MockClient)(nil).Upsert), tx, stmt, key, obj, shouldEncrypt)
}
// WithTransaction mocks base method.
func (m *MockClient) WithTransaction(arg0 context.Context, arg1 bool, arg2 db.WithTransactionFunction) error {
func (m *MockClient) WithTransaction(ctx context.Context, forWriting bool, f db.WithTransactionFunction) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WithTransaction", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "WithTransaction", ctx, forWriting, f)
ret0, _ := ret[0].(error)
return ret0
}
// WithTransaction indicates an expected call of WithTransaction.
func (mr *MockClientMockRecorder) WithTransaction(arg0, arg1, arg2 any) *gomock.Call {
func (mr *MockClientMockRecorder) WithTransaction(ctx, forWriting, f any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTransaction", reflect.TypeOf((*MockClient)(nil).WithTransaction), arg0, arg1, arg2)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTransaction", reflect.TypeOf((*MockClient)(nil).WithTransaction), ctx, forWriting, f)
}

56
pkg/sqlcache/store/transaction_mocks_test.go
View File

@@ -22,6 +22,7 @@ import (
type MockStmt struct {
ctrl *gomock.Controller
recorder *MockStmtMockRecorder
isgomock struct{}
}
// MockStmtMockRecorder is the mock recorder for MockStmt.
@@ -42,10 +43,10 @@ func (m *MockStmt) EXPECT() *MockStmtMockRecorder {
}
// Exec mocks base method.
func (m *MockStmt) Exec(arg0 ...any) (sql.Result, error) {
func (m *MockStmt) Exec(args ...any) (sql.Result, error) {
m.ctrl.T.Helper()
varargs := []any{}
for _, a := range arg0 {
for _, a := range args {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Exec", varargs...)
@@ -55,16 +56,16 @@ func (m *MockStmt) Exec(arg0 ...any) (sql.Result, error) {
}
// Exec indicates an expected call of Exec.
func (mr *MockStmtMockRecorder) Exec(arg0 ...any) *gomock.Call {
func (mr *MockStmtMockRecorder) Exec(args ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockStmt)(nil).Exec), arg0...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockStmt)(nil).Exec), args...)
}
// Query mocks base method.
func (m *MockStmt) Query(arg0 ...any) (*sql.Rows, error) {
func (m *MockStmt) Query(args ...any) (*sql.Rows, error) {
m.ctrl.T.Helper()
varargs := []any{}
for _, a := range arg0 {
for _, a := range args {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Query", varargs...)
@@ -74,16 +75,16 @@ func (m *MockStmt) Query(arg0 ...any) (*sql.Rows, error) {
}
// Query indicates an expected call of Query.
func (mr *MockStmtMockRecorder) Query(arg0 ...any) *gomock.Call {
func (mr *MockStmtMockRecorder) Query(args ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStmt)(nil).Query), arg0...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStmt)(nil).Query), args...)
}
// QueryContext mocks base method.
func (m *MockStmt) QueryContext(arg0 context.Context, arg1 ...any) (*sql.Rows, error) {
func (m *MockStmt) QueryContext(ctx context.Context, args ...any) (*sql.Rows, error) {
m.ctrl.T.Helper()
varargs := []any{arg0}
for _, a := range arg1 {
varargs := []any{ctx}
for _, a := range args {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "QueryContext", varargs...)
@@ -93,17 +94,17 @@ func (m *MockStmt) QueryContext(arg0 context.Context, arg1 ...any) (*sql.Rows, e
}
// QueryContext indicates an expected call of QueryContext.
func (mr *MockStmtMockRecorder) QueryContext(arg0 any, arg1 ...any) *gomock.Call {
func (mr *MockStmtMockRecorder) QueryContext(ctx any, args ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0}, arg1...)
varargs := append([]any{ctx}, args...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryContext", reflect.TypeOf((*MockStmt)(nil).QueryContext), varargs...)
}
// QueryRowContext mocks base method.
func (m *MockStmt) QueryRowContext(arg0 context.Context, arg1 ...any) *sql.Row {
func (m *MockStmt) QueryRowContext(ctx context.Context, args ...any) *sql.Row {
m.ctrl.T.Helper()
varargs := []any{arg0}
for _, a := range arg1 {
varargs := []any{ctx}
for _, a := range args {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "QueryRowContext", varargs...)
@@ -112,9 +113,9 @@ func (m *MockStmt) QueryRowContext(arg0 context.Context, arg1 ...any) *sql.Row {
}
// QueryRowContext indicates an expected call of QueryRowContext.
func (mr *MockStmtMockRecorder) QueryRowContext(arg0 any, arg1 ...any) *gomock.Call {
func (mr *MockStmtMockRecorder) QueryRowContext(ctx any, args ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0}, arg1...)
varargs := append([]any{ctx}, args...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRowContext", reflect.TypeOf((*MockStmt)(nil).QueryRowContext), varargs...)
}
@@ -122,6 +123,7 @@ func (mr *MockStmtMockRecorder) QueryRowContext(arg0 any, arg1 ...any) *gomock.C
type MockTXClient struct {
ctrl *gomock.Controller
recorder *MockTXClientMockRecorder
isgomock struct{}
}
// MockTXClientMockRecorder is the mock recorder for MockTXClient.
@@ -142,10 +144,10 @@ func (m *MockTXClient) EXPECT() *MockTXClientMockRecorder {
}
// Exec mocks base method.
func (m *MockTXClient) Exec(arg0 string, arg1 ...any) (sql.Result, error) {
func (m *MockTXClient) Exec(query string, args ...any) (sql.Result, error) {
m.ctrl.T.Helper()
varargs := []any{arg0}
for _, a := range arg1 {
varargs := []any{query}
for _, a := range args {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Exec", varargs...)
@@ -155,22 +157,22 @@ func (m *MockTXClient) Exec(arg0 string, arg1 ...any) (sql.Result, error) {
}
// Exec indicates an expected call of Exec.
func (mr *MockTXClientMockRecorder) Exec(arg0 any, arg1 ...any) *gomock.Call {
func (mr *MockTXClientMockRecorder) Exec(query any, args ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0}, arg1...)
varargs := append([]any{query}, args...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockTXClient)(nil).Exec), varargs...)
}
// Stmt mocks base method.
func (m *MockTXClient) Stmt(arg0 *sql.Stmt) transaction.Stmt {
func (m *MockTXClient) Stmt(stmt *sql.Stmt) transaction.Stmt {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Stmt", arg0)
ret := m.ctrl.Call(m, "Stmt", stmt)
ret0, _ := ret[0].(transaction.Stmt)
return ret0
}
// Stmt indicates an expected call of Stmt.
func (mr *MockTXClientMockRecorder) Stmt(arg0 any) *gomock.Call {
func (mr *MockTXClientMockRecorder) Stmt(stmt any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stmt", reflect.TypeOf((*MockTXClient)(nil).Stmt), arg0)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stmt", reflect.TypeOf((*MockTXClient)(nil).Stmt), stmt)
}