chore(deps): update module github.com/vektra/mockery/v3 to v3.3.0 (#1343)

* chore(deps): update module github.com/vektra/mockery/v3 to v3.3.0

* Generated by GitHub Actions (go / generate)

https://github.com/int128/kubelogin/actions/runs/15264974955

* Empty commit to trigger GitHub Actions

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: update-generated-files-action <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: int128-renovate-merge-bot[bot] <132176788+int128-renovate-merge-bot[bot]@users.noreply.github.com>

mocks/github.com/int128/kubelogin/integration_test/oidcserver/service_mock/mocks.go

@@ -69,14 +69,20 @@ type MockService_AuthenticateCode_Call struct {
 }
 
 // AuthenticateCode is a helper method to define mock.On call
-//   - req
+//   - req service.AuthenticationRequest
 func (_e *MockService_Expecter) AuthenticateCode(req interface{}) *MockService_AuthenticateCode_Call {
 	return &MockService_AuthenticateCode_Call{Call: _e.mock.On("AuthenticateCode", req)}
 }
 
 func (_c *MockService_AuthenticateCode_Call) Run(run func(req service.AuthenticationRequest)) *MockService_AuthenticateCode_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(service.AuthenticationRequest))
+		var arg0 service.AuthenticationRequest
+		if args[0] != nil {
+			arg0 = args[0].(service.AuthenticationRequest)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -125,16 +131,32 @@ type MockService_AuthenticatePassword_Call struct {
 }
 
 // AuthenticatePassword is a helper method to define mock.On call
-//   - username
-//   - password
-//   - scope
+//   - username string
+//   - password string
+//   - scope string
 func (_e *MockService_Expecter) AuthenticatePassword(username interface{}, password interface{}, scope interface{}) *MockService_AuthenticatePassword_Call {
 	return &MockService_AuthenticatePassword_Call{Call: _e.mock.On("AuthenticatePassword", username, password, scope)}
 }
 
 func (_c *MockService_AuthenticatePassword_Call) Run(run func(username string, password string, scope string)) *MockService_AuthenticatePassword_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string), args[2].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }
@@ -229,14 +251,20 @@ type MockService_Exchange_Call struct {
 }
 
 // Exchange is a helper method to define mock.On call
-//   - req
+//   - req service.TokenRequest
 func (_e *MockService_Expecter) Exchange(req interface{}) *MockService_Exchange_Call {
 	return &MockService_Exchange_Call{Call: _e.mock.On("Exchange", req)}
 }
 
 func (_c *MockService_Exchange_Call) Run(run func(req service.TokenRequest)) *MockService_Exchange_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(service.TokenRequest))
+		var arg0 service.TokenRequest
+		if args[0] != nil {
+			arg0 = args[0].(service.TokenRequest)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -421,14 +449,20 @@ type MockService_Refresh_Call struct {
 }
 
 // Refresh is a helper method to define mock.On call
-//   - refreshToken
+//   - refreshToken string
 func (_e *MockService_Expecter) Refresh(refreshToken interface{}) *MockService_Refresh_Call {
 	return &MockService_Refresh_Call{Call: _e.mock.On("Refresh", refreshToken)}
 }
 
 func (_c *MockService_Refresh_Call) Run(run func(refreshToken string)) *MockService_Refresh_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -455,14 +489,20 @@ type MockService_SetConfig_Call struct {
 }
 
 // SetConfig is a helper method to define mock.On call
-//   - config
+//   - config testconfig.Config
 func (_e *MockService_Expecter) SetConfig(config interface{}) *MockService_SetConfig_Call {
 	return &MockService_SetConfig_Call{Call: _e.mock.On("SetConfig", config)}
 }
 
 func (_c *MockService_SetConfig_Call) Run(run func(config testconfig.Config)) *MockService_SetConfig_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(testconfig.Config))
+		var arg0 testconfig.Config
+		if args[0] != nil {
+			arg0 = args[0].(testconfig.Config)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -536,14 +576,20 @@ type MockProvider_AuthenticateCode_Call struct {
 }
 
 // AuthenticateCode is a helper method to define mock.On call
-//   - req
+//   - req service.AuthenticationRequest
 func (_e *MockProvider_Expecter) AuthenticateCode(req interface{}) *MockProvider_AuthenticateCode_Call {
 	return &MockProvider_AuthenticateCode_Call{Call: _e.mock.On("AuthenticateCode", req)}
 }
 
 func (_c *MockProvider_AuthenticateCode_Call) Run(run func(req service.AuthenticationRequest)) *MockProvider_AuthenticateCode_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(service.AuthenticationRequest))
+		var arg0 service.AuthenticationRequest
+		if args[0] != nil {
+			arg0 = args[0].(service.AuthenticationRequest)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -592,16 +638,32 @@ type MockProvider_AuthenticatePassword_Call struct {
 }
 
 // AuthenticatePassword is a helper method to define mock.On call
-//   - username
-//   - password
-//   - scope
+//   - username string
+//   - password string
+//   - scope string
 func (_e *MockProvider_Expecter) AuthenticatePassword(username interface{}, password interface{}, scope interface{}) *MockProvider_AuthenticatePassword_Call {
 	return &MockProvider_AuthenticatePassword_Call{Call: _e.mock.On("AuthenticatePassword", username, password, scope)}
 }
 
 func (_c *MockProvider_AuthenticatePassword_Call) Run(run func(username string, password string, scope string)) *MockProvider_AuthenticatePassword_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string), args[2].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }
@@ -696,14 +758,20 @@ type MockProvider_Exchange_Call struct {
 }
 
 // Exchange is a helper method to define mock.On call
-//   - req
+//   - req service.TokenRequest
 func (_e *MockProvider_Expecter) Exchange(req interface{}) *MockProvider_Exchange_Call {
 	return &MockProvider_Exchange_Call{Call: _e.mock.On("Exchange", req)}
 }
 
 func (_c *MockProvider_Exchange_Call) Run(run func(req service.TokenRequest)) *MockProvider_Exchange_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(service.TokenRequest))
+		var arg0 service.TokenRequest
+		if args[0] != nil {
+			arg0 = args[0].(service.TokenRequest)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -798,14 +866,20 @@ type MockProvider_Refresh_Call struct {
 }
 
 // Refresh is a helper method to define mock.On call
-//   - refreshToken
+//   - refreshToken string
 func (_e *MockProvider_Expecter) Refresh(refreshToken interface{}) *MockProvider_Refresh_Call {
 	return &MockProvider_Refresh_Call{Call: _e.mock.On("Refresh", refreshToken)}
 }
 
 func (_c *MockProvider_Refresh_Call) Run(run func(refreshToken string)) *MockProvider_Refresh_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/cmd_mock/mocks.go

@@ -60,16 +60,32 @@ type MockInterface_Run_Call struct {
 }
 
 // Run is a helper method to define mock.On call
-//   - ctx
-//   - args
-//   - version
+//   - ctx context.Context
+//   - args []string
+//   - version string
 func (_e *MockInterface_Expecter) Run(ctx interface{}, args interface{}, version interface{}) *MockInterface_Run_Call {
 	return &MockInterface_Run_Call{Call: _e.mock.On("Run", ctx, args, version)}
 }
 
 func (_c *MockInterface_Run_Call) Run(run func(ctx context.Context, args []string, version string)) *MockInterface_Run_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].([]string), args[2].(string))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 []string
+		if args[1] != nil {
+			arg1 = args[1].([]string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/credentialplugin/writer_mock/mocks.go

@@ -59,14 +59,20 @@ type MockInterface_Write_Call struct {
 }
 
 // Write is a helper method to define mock.On call
-//   - out
+//   - out credentialplugin.Output
 func (_e *MockInterface_Expecter) Write(out interface{}) *MockInterface_Write_Call {
 	return &MockInterface_Write_Call{Call: _e.mock.On("Write", out)}
 }
 
 func (_c *MockInterface_Write_Call) Run(run func(out credentialplugin.Output)) *MockInterface_Write_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(credentialplugin.Output))
+		var arg0 credentialplugin.Output
+		if args[0] != nil {
+			arg0 = args[0].(credentialplugin.Output)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/infrastructure/browser_mock/mocks.go

@@ -60,14 +60,20 @@ type MockInterface_Open_Call struct {
 }
 
 // Open is a helper method to define mock.On call
-//   - url
+//   - url string
 func (_e *MockInterface_Expecter) Open(url interface{}) *MockInterface_Open_Call {
 	return &MockInterface_Open_Call{Call: _e.mock.On("Open", url)}
 }
 
 func (_c *MockInterface_Open_Call) Run(run func(url string)) *MockInterface_Open_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -105,16 +111,32 @@ type MockInterface_OpenCommand_Call struct {
 }
 
 // OpenCommand is a helper method to define mock.On call
-//   - ctx
-//   - url
-//   - command
+//   - ctx context.Context
+//   - url string
+//   - command string
 func (_e *MockInterface_Expecter) OpenCommand(ctx interface{}, url interface{}, command interface{}) *MockInterface_OpenCommand_Call {
 	return &MockInterface_OpenCommand_Call{Call: _e.mock.On("OpenCommand", ctx, url, command)}
 }
 
 func (_c *MockInterface_OpenCommand_Call) Run(run func(ctx context.Context, url string, command string)) *MockInterface_OpenCommand_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(string), args[2].(string))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/infrastructure/logger_mock/mocks.go

@@ -49,14 +49,20 @@ type MockInterface_AddFlags_Call struct {
 }
 
 // AddFlags is a helper method to define mock.On call
-//   - f
+//   - f *pflag.FlagSet
 func (_e *MockInterface_Expecter) AddFlags(f interface{}) *MockInterface_AddFlags_Call {
 	return &MockInterface_AddFlags_Call{Call: _e.mock.On("AddFlags", f)}
 }
 
 func (_c *MockInterface_AddFlags_Call) Run(run func(f *pflag.FlagSet)) *MockInterface_AddFlags_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*pflag.FlagSet))
+		var arg0 *pflag.FlagSet
+		if args[0] != nil {
+			arg0 = args[0].(*pflag.FlagSet)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -94,14 +100,20 @@ type MockInterface_IsEnabled_Call struct {
 }
 
 // IsEnabled is a helper method to define mock.On call
-//   - level
+//   - level int
 func (_e *MockInterface_Expecter) IsEnabled(level interface{}) *MockInterface_IsEnabled_Call {
 	return &MockInterface_IsEnabled_Call{Call: _e.mock.On("IsEnabled", level)}
 }
 
 func (_c *MockInterface_IsEnabled_Call) Run(run func(level int)) *MockInterface_IsEnabled_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(int))
+		var arg0 int
+		if args[0] != nil {
+			arg0 = args[0].(int)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -133,8 +145,8 @@ type MockInterface_Printf_Call struct {
 }
 
 // Printf is a helper method to define mock.On call
-//   - format
-//   - args
+//   - format string
+//   - args ...interface{}
 func (_e *MockInterface_Expecter) Printf(format interface{}, args ...interface{}) *MockInterface_Printf_Call {
 	return &MockInterface_Printf_Call{Call: _e.mock.On("Printf",
 		append([]interface{}{format}, args...)...)}
@@ -142,8 +154,17 @@ func (_e *MockInterface_Expecter) Printf(format interface{}, args ...interface{}
 
 func (_c *MockInterface_Printf_Call) Run(run func(format string, args ...interface{})) *MockInterface_Printf_Call {
 	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 []interface{}
 		variadicArgs := args[1].([]interface{})
-		run(args[0].(string), variadicArgs...)
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
 	})
 	return _c
 }
@@ -183,14 +204,20 @@ type MockInterface_V_Call struct {
 }
 
 // V is a helper method to define mock.On call
-//   - level
+//   - level int
 func (_e *MockInterface_Expecter) V(level interface{}) *MockInterface_V_Call {
 	return &MockInterface_V_Call{Call: _e.mock.On("V", level)}
 }
 
 func (_c *MockInterface_V_Call) Run(run func(level int)) *MockInterface_V_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(int))
+		var arg0 int
+		if args[0] != nil {
+			arg0 = args[0].(int)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -249,8 +276,8 @@ type MockVerbose_Infof_Call struct {
 }
 
 // Infof is a helper method to define mock.On call
-//   - format
-//   - args
+//   - format string
+//   - args ...interface{}
 func (_e *MockVerbose_Expecter) Infof(format interface{}, args ...interface{}) *MockVerbose_Infof_Call {
 	return &MockVerbose_Infof_Call{Call: _e.mock.On("Infof",
 		append([]interface{}{format}, args...)...)}
@@ -258,8 +285,17 @@ func (_e *MockVerbose_Expecter) Infof(format interface{}, args ...interface{}) *
 
 func (_c *MockVerbose_Infof_Call) Run(run func(format string, args ...interface{})) *MockVerbose_Infof_Call {
 	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 []interface{}
 		variadicArgs := args[1].([]interface{})
-		run(args[0].(string), variadicArgs...)
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
 	})
 	return _c
 }
@@ -318,8 +354,8 @@ type mockgoLogger_Printf_Call struct {
 }
 
 // Printf is a helper method to define mock.On call
-//   - format
-//   - v
+//   - format string
+//   - v ...interface{}
 func (_e *mockgoLogger_Expecter) Printf(format interface{}, v ...interface{}) *mockgoLogger_Printf_Call {
 	return &mockgoLogger_Printf_Call{Call: _e.mock.On("Printf",
 		append([]interface{}{format}, v...)...)}
@@ -327,8 +363,17 @@ func (_e *mockgoLogger_Expecter) Printf(format interface{}, v ...interface{}) *m
 
 func (_c *mockgoLogger_Printf_Call) Run(run func(format string, v ...interface{})) *mockgoLogger_Printf_Call {
 	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 []interface{}
 		variadicArgs := args[1].([]interface{})
-		run(args[0].(string), variadicArgs...)
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/infrastructure/reader_mock/mocks.go

@@ -67,14 +67,20 @@ type MockInterface_ReadPassword_Call struct {
 }
 
 // ReadPassword is a helper method to define mock.On call
-//   - prompt
+//   - prompt string
 func (_e *MockInterface_Expecter) ReadPassword(prompt interface{}) *MockInterface_ReadPassword_Call {
 	return &MockInterface_ReadPassword_Call{Call: _e.mock.On("ReadPassword", prompt)}
 }
 
 func (_c *MockInterface_ReadPassword_Call) Run(run func(prompt string)) *MockInterface_ReadPassword_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -121,14 +127,20 @@ type MockInterface_ReadString_Call struct {
 }
 
 // ReadString is a helper method to define mock.On call
-//   - prompt
+//   - prompt string
 func (_e *MockInterface_Expecter) ReadString(prompt interface{}) *MockInterface_ReadString_Call {
 	return &MockInterface_ReadString_Call{Call: _e.mock.On("ReadString", prompt)}
 }
 
 func (_c *MockInterface_ReadString_Call) Run(run func(prompt string)) *MockInterface_ReadString_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/kubeconfig/loader_mock/mocks.go

@@ -70,16 +70,32 @@ type MockInterface_GetCurrentAuthProvider_Call struct {
 }
 
 // GetCurrentAuthProvider is a helper method to define mock.On call
-//   - explicitFilename
-//   - contextName
-//   - userName
+//   - explicitFilename string
+//   - contextName kubeconfig.ContextName
+//   - userName kubeconfig.UserName
 func (_e *MockInterface_Expecter) GetCurrentAuthProvider(explicitFilename interface{}, contextName interface{}, userName interface{}) *MockInterface_GetCurrentAuthProvider_Call {
 	return &MockInterface_GetCurrentAuthProvider_Call{Call: _e.mock.On("GetCurrentAuthProvider", explicitFilename, contextName, userName)}
 }
 
 func (_c *MockInterface_GetCurrentAuthProvider_Call) Run(run func(explicitFilename string, contextName kubeconfig.ContextName, userName kubeconfig.UserName)) *MockInterface_GetCurrentAuthProvider_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(kubeconfig.ContextName), args[2].(kubeconfig.UserName))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 kubeconfig.ContextName
+		if args[1] != nil {
+			arg1 = args[1].(kubeconfig.ContextName)
+		}
+		var arg2 kubeconfig.UserName
+		if args[2] != nil {
+			arg2 = args[2].(kubeconfig.UserName)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/kubeconfig/writer_mock/mocks.go

@@ -59,14 +59,20 @@ type MockInterface_UpdateAuthProvider_Call struct {
 }
 
 // UpdateAuthProvider is a helper method to define mock.On call
-//   - p
+//   - p kubeconfig.AuthProvider
 func (_e *MockInterface_Expecter) UpdateAuthProvider(p interface{}) *MockInterface_UpdateAuthProvider_Call {
 	return &MockInterface_UpdateAuthProvider_Call{Call: _e.mock.On("UpdateAuthProvider", p)}
 }
 
 func (_c *MockInterface_UpdateAuthProvider_Call) Run(run func(p kubeconfig.AuthProvider)) *MockInterface_UpdateAuthProvider_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(kubeconfig.AuthProvider))
+		var arg0 kubeconfig.AuthProvider
+		if args[0] != nil {
+			arg0 = args[0].(kubeconfig.AuthProvider)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/oidc/client_mock/mocks.go

@@ -76,15 +76,26 @@ type MockInterface_ExchangeAuthCode_Call struct {
 }
 
 // ExchangeAuthCode is a helper method to define mock.On call
-//   - ctx
-//   - in
+//   - ctx context.Context
+//   - in client.ExchangeAuthCodeInput
 func (_e *MockInterface_Expecter) ExchangeAuthCode(ctx interface{}, in interface{}) *MockInterface_ExchangeAuthCode_Call {
 	return &MockInterface_ExchangeAuthCode_Call{Call: _e.mock.On("ExchangeAuthCode", ctx, in)}
 }
 
 func (_c *MockInterface_ExchangeAuthCode_Call) Run(run func(ctx context.Context, in client.ExchangeAuthCodeInput)) *MockInterface_ExchangeAuthCode_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(client.ExchangeAuthCodeInput))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 client.ExchangeAuthCodeInput
+		if args[1] != nil {
+			arg1 = args[1].(client.ExchangeAuthCodeInput)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
@@ -133,15 +144,26 @@ type MockInterface_ExchangeDeviceCode_Call struct {
 }
 
 // ExchangeDeviceCode is a helper method to define mock.On call
-//   - ctx
-//   - authResponse
+//   - ctx context.Context
+//   - authResponse *oauth2dev.AuthorizationResponse
 func (_e *MockInterface_Expecter) ExchangeDeviceCode(ctx interface{}, authResponse interface{}) *MockInterface_ExchangeDeviceCode_Call {
 	return &MockInterface_ExchangeDeviceCode_Call{Call: _e.mock.On("ExchangeDeviceCode", ctx, authResponse)}
 }
 
 func (_c *MockInterface_ExchangeDeviceCode_Call) Run(run func(ctx context.Context, authResponse *oauth2dev.AuthorizationResponse)) *MockInterface_ExchangeDeviceCode_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*oauth2dev.AuthorizationResponse))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *oauth2dev.AuthorizationResponse
+		if args[1] != nil {
+			arg1 = args[1].(*oauth2dev.AuthorizationResponse)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
@@ -179,14 +201,20 @@ type MockInterface_GetAuthCodeURL_Call struct {
 }
 
 // GetAuthCodeURL is a helper method to define mock.On call
-//   - in
+//   - in client.AuthCodeURLInput
 func (_e *MockInterface_Expecter) GetAuthCodeURL(in interface{}) *MockInterface_GetAuthCodeURL_Call {
 	return &MockInterface_GetAuthCodeURL_Call{Call: _e.mock.On("GetAuthCodeURL", in)}
 }
 
 func (_c *MockInterface_GetAuthCodeURL_Call) Run(run func(in client.AuthCodeURLInput)) *MockInterface_GetAuthCodeURL_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(client.AuthCodeURLInput))
+		var arg0 client.AuthCodeURLInput
+		if args[0] != nil {
+			arg0 = args[0].(client.AuthCodeURLInput)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -235,14 +263,20 @@ type MockInterface_GetDeviceAuthorization_Call struct {
 }
 
 // GetDeviceAuthorization is a helper method to define mock.On call
-//   - ctx
+//   - ctx context.Context
 func (_e *MockInterface_Expecter) GetDeviceAuthorization(ctx interface{}) *MockInterface_GetDeviceAuthorization_Call {
 	return &MockInterface_GetDeviceAuthorization_Call{Call: _e.mock.On("GetDeviceAuthorization", ctx)}
 }
 
 func (_c *MockInterface_GetDeviceAuthorization_Call) Run(run func(ctx context.Context)) *MockInterface_GetDeviceAuthorization_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -291,16 +325,32 @@ type MockInterface_GetTokenByAuthCode_Call struct {
 }
 
 // GetTokenByAuthCode is a helper method to define mock.On call
-//   - ctx
-//   - in
-//   - localServerReadyChan
+//   - ctx context.Context
+//   - in client.GetTokenByAuthCodeInput
+//   - localServerReadyChan chan<- string
 func (_e *MockInterface_Expecter) GetTokenByAuthCode(ctx interface{}, in interface{}, localServerReadyChan interface{}) *MockInterface_GetTokenByAuthCode_Call {
 	return &MockInterface_GetTokenByAuthCode_Call{Call: _e.mock.On("GetTokenByAuthCode", ctx, in, localServerReadyChan)}
 }
 
 func (_c *MockInterface_GetTokenByAuthCode_Call) Run(run func(ctx context.Context, in client.GetTokenByAuthCodeInput, localServerReadyChan chan<- string)) *MockInterface_GetTokenByAuthCode_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(client.GetTokenByAuthCodeInput), args[2].(chan<- string))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 client.GetTokenByAuthCodeInput
+		if args[1] != nil {
+			arg1 = args[1].(client.GetTokenByAuthCodeInput)
+		}
+		var arg2 chan<- string
+		if args[2] != nil {
+			arg2 = args[2].(chan<- string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }
@@ -349,16 +399,32 @@ type MockInterface_GetTokenByROPC_Call struct {
 }
 
 // GetTokenByROPC is a helper method to define mock.On call
-//   - ctx
-//   - username
-//   - password
+//   - ctx context.Context
+//   - username string
+//   - password string
 func (_e *MockInterface_Expecter) GetTokenByROPC(ctx interface{}, username interface{}, password interface{}) *MockInterface_GetTokenByROPC_Call {
 	return &MockInterface_GetTokenByROPC_Call{Call: _e.mock.On("GetTokenByROPC", ctx, username, password)}
 }
 
 func (_c *MockInterface_GetTokenByROPC_Call) Run(run func(ctx context.Context, username string, password string)) *MockInterface_GetTokenByROPC_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(string), args[2].(string))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 string
+		if args[2] != nil {
+			arg2 = args[2].(string)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }
@@ -451,15 +517,26 @@ type MockInterface_Refresh_Call struct {
 }
 
 // Refresh is a helper method to define mock.On call
-//   - ctx
-//   - refreshToken
+//   - ctx context.Context
+//   - refreshToken string
 func (_e *MockInterface_Expecter) Refresh(ctx interface{}, refreshToken interface{}) *MockInterface_Refresh_Call {
 	return &MockInterface_Refresh_Call{Call: _e.mock.On("Refresh", ctx, refreshToken)}
 }
 
 func (_c *MockInterface_Refresh_Call) Run(run func(ctx context.Context, refreshToken string)) *MockInterface_Refresh_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(string))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
@@ -535,16 +612,32 @@ type MockFactoryInterface_New_Call struct {
 }
 
 // New is a helper method to define mock.On call
-//   - ctx
-//   - prov
-//   - tlsClientConfig
+//   - ctx context.Context
+//   - prov oidc.Provider
+//   - tlsClientConfig tlsclientconfig.Config
 func (_e *MockFactoryInterface_Expecter) New(ctx interface{}, prov interface{}, tlsClientConfig interface{}) *MockFactoryInterface_New_Call {
 	return &MockFactoryInterface_New_Call{Call: _e.mock.On("New", ctx, prov, tlsClientConfig)}
 }
 
 func (_c *MockFactoryInterface_New_Call) Run(run func(ctx context.Context, prov oidc.Provider, tlsClientConfig tlsclientconfig.Config)) *MockFactoryInterface_New_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(oidc.Provider), args[2].(tlsclientconfig.Config))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 oidc.Provider
+		if args[1] != nil {
+			arg1 = args[1].(oidc.Provider)
+		}
+		var arg2 tlsclientconfig.Config
+		if args[2] != nil {
+			arg2 = args[2].(tlsclientconfig.Config)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/testing/logger_mock/mocks.go

@@ -52,8 +52,8 @@ type mocktestingLogger_Logf_Call struct {
 }
 
 // Logf is a helper method to define mock.On call
-//   - format
-//   - v
+//   - format string
+//   - v ...interface{}
 func (_e *mocktestingLogger_Expecter) Logf(format interface{}, v ...interface{}) *mocktestingLogger_Logf_Call {
 	return &mocktestingLogger_Logf_Call{Call: _e.mock.On("Logf",
 		append([]interface{}{format}, v...)...)}
@@ -61,8 +61,17 @@ func (_e *mocktestingLogger_Expecter) Logf(format interface{}, v ...interface{})
 
 func (_c *mocktestingLogger_Logf_Call) Run(run func(format string, v ...interface{})) *mocktestingLogger_Logf_Call {
 	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 []interface{}
 		variadicArgs := args[1].([]interface{})
-		run(args[0].(string), variadicArgs...)
+		arg1 = variadicArgs
+		run(
+			arg0,
+			arg1...,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/tlsclientconfig/loader_mock/mocks.go

@@ -72,14 +72,20 @@ type MockInterface_Load_Call struct {
 }
 
 // Load is a helper method to define mock.On call
-//   - config
+//   - config tlsclientconfig.Config
 func (_e *MockInterface_Expecter) Load(config interface{}) *MockInterface_Load_Call {
 	return &MockInterface_Load_Call{Call: _e.mock.On("Load", config)}
 }
 
 func (_c *MockInterface_Load_Call) Run(run func(config tlsclientconfig.Config)) *MockInterface_Load_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(tlsclientconfig.Config))
+		var arg0 tlsclientconfig.Config
+		if args[0] != nil {
+			arg0 = args[0].(tlsclientconfig.Config)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/tokencache/repository_mock/mocks.go

@@ -62,14 +62,20 @@ type MockInterface_DeleteAll_Call struct {
 }
 
 // DeleteAll is a helper method to define mock.On call
-//   - config
+//   - config tokencache.Config
 func (_e *MockInterface_Expecter) DeleteAll(config interface{}) *MockInterface_DeleteAll_Call {
 	return &MockInterface_DeleteAll_Call{Call: _e.mock.On("DeleteAll", config)}
 }
 
 func (_c *MockInterface_DeleteAll_Call) Run(run func(config tokencache.Config)) *MockInterface_DeleteAll_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(tokencache.Config))
+		var arg0 tokencache.Config
+		if args[0] != nil {
+			arg0 = args[0].(tokencache.Config)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -118,15 +124,26 @@ type MockInterface_FindByKey_Call struct {
 }
 
 // FindByKey is a helper method to define mock.On call
-//   - config
-//   - key
+//   - config tokencache.Config
+//   - key tokencache.Key
 func (_e *MockInterface_Expecter) FindByKey(config interface{}, key interface{}) *MockInterface_FindByKey_Call {
 	return &MockInterface_FindByKey_Call{Call: _e.mock.On("FindByKey", config, key)}
 }
 
 func (_c *MockInterface_FindByKey_Call) Run(run func(config tokencache.Config, key tokencache.Key)) *MockInterface_FindByKey_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(tokencache.Config), args[1].(tokencache.Key))
+		var arg0 tokencache.Config
+		if args[0] != nil {
+			arg0 = args[0].(tokencache.Config)
+		}
+		var arg1 tokencache.Key
+		if args[1] != nil {
+			arg1 = args[1].(tokencache.Key)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
@@ -175,15 +192,26 @@ type MockInterface_Lock_Call struct {
 }
 
 // Lock is a helper method to define mock.On call
-//   - config
-//   - key
+//   - config tokencache.Config
+//   - key tokencache.Key
 func (_e *MockInterface_Expecter) Lock(config interface{}, key interface{}) *MockInterface_Lock_Call {
 	return &MockInterface_Lock_Call{Call: _e.mock.On("Lock", config, key)}
 }
 
 func (_c *MockInterface_Lock_Call) Run(run func(config tokencache.Config, key tokencache.Key)) *MockInterface_Lock_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(tokencache.Config), args[1].(tokencache.Key))
+		var arg0 tokencache.Config
+		if args[0] != nil {
+			arg0 = args[0].(tokencache.Config)
+		}
+		var arg1 tokencache.Key
+		if args[1] != nil {
+			arg1 = args[1].(tokencache.Key)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
@@ -221,16 +249,32 @@ type MockInterface_Save_Call struct {
 }
 
 // Save is a helper method to define mock.On call
-//   - config
-//   - key
-//   - tokenSet
+//   - config tokencache.Config
+//   - key tokencache.Key
+//   - tokenSet oidc.TokenSet
 func (_e *MockInterface_Expecter) Save(config interface{}, key interface{}, tokenSet interface{}) *MockInterface_Save_Call {
 	return &MockInterface_Save_Call{Call: _e.mock.On("Save", config, key, tokenSet)}
 }
 
 func (_c *MockInterface_Save_Call) Run(run func(config tokencache.Config, key tokencache.Key, tokenSet oidc.TokenSet)) *MockInterface_Save_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(tokencache.Config), args[1].(tokencache.Key), args[2].(oidc.TokenSet))
+		var arg0 tokencache.Config
+		if args[0] != nil {
+			arg0 = args[0].(tokencache.Config)
+		}
+		var arg1 tokencache.Key
+		if args[1] != nil {
+			arg1 = args[1].(tokencache.Key)
+		}
+		var arg2 oidc.TokenSet
+		if args[2] != nil {
+			arg2 = args[2].(oidc.TokenSet)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/usecases/authentication_mock/mocks.go

@@ -72,15 +72,26 @@ type MockInterface_Do_Call struct {
 }
 
 // Do is a helper method to define mock.On call
-//   - ctx
-//   - in
+//   - ctx context.Context
+//   - in authentication.Input
 func (_e *MockInterface_Expecter) Do(ctx interface{}, in interface{}) *MockInterface_Do_Call {
 	return &MockInterface_Do_Call{Call: _e.mock.On("Do", ctx, in)}
 }
 
 func (_c *MockInterface_Do_Call) Run(run func(ctx context.Context, in authentication.Input)) *MockInterface_Do_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(authentication.Input))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 authentication.Input
+		if args[1] != nil {
+			arg1 = args[1].(authentication.Input)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/usecases/clean_mock/mocks.go

@@ -61,15 +61,26 @@ type MockInterface_Do_Call struct {
 }
 
 // Do is a helper method to define mock.On call
-//   - ctx
-//   - in
+//   - ctx context.Context
+//   - in clean.Input
 func (_e *MockInterface_Expecter) Do(ctx interface{}, in interface{}) *MockInterface_Do_Call {
 	return &MockInterface_Do_Call{Call: _e.mock.On("Do", ctx, in)}
 }
 
 func (_c *MockInterface_Do_Call) Run(run func(ctx context.Context, in clean.Input)) *MockInterface_Do_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(clean.Input))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 clean.Input
+		if args[1] != nil {
+			arg1 = args[1].(clean.Input)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/usecases/credentialplugin_mock/mocks.go

@@ -61,15 +61,26 @@ type MockInterface_Do_Call struct {
 }
 
 // Do is a helper method to define mock.On call
-//   - ctx
-//   - in
+//   - ctx context.Context
+//   - in credentialplugin.Input
 func (_e *MockInterface_Expecter) Do(ctx interface{}, in interface{}) *MockInterface_Do_Call {
 	return &MockInterface_Do_Call{Call: _e.mock.On("Do", ctx, in)}
 }
 
 func (_c *MockInterface_Do_Call) Run(run func(ctx context.Context, in credentialplugin.Input)) *MockInterface_Do_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(credentialplugin.Input))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 credentialplugin.Input
+		if args[1] != nil {
+			arg1 = args[1].(credentialplugin.Input)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/usecases/setup_mock/mocks.go

@@ -61,15 +61,26 @@ type MockInterface_Do_Call struct {
 }
 
 // Do is a helper method to define mock.On call
-//   - ctx
-//   - in
+//   - ctx context.Context
+//   - in setup.Input
 func (_e *MockInterface_Expecter) Do(ctx interface{}, in interface{}) *MockInterface_Do_Call {
 	return &MockInterface_Do_Call{Call: _e.mock.On("Do", ctx, in)}
 }
 
 func (_c *MockInterface_Do_Call) Run(run func(ctx context.Context, in setup.Input)) *MockInterface_Do_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(setup.Input))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 setup.Input
+		if args[1] != nil {
+			arg1 = args[1].(setup.Input)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }

mocks/github.com/int128/kubelogin/pkg/usecases/standalone_mock/mocks.go

@@ -61,15 +61,26 @@ type MockInterface_Do_Call struct {
 }
 
 // Do is a helper method to define mock.On call
-//   - ctx
-//   - in
+//   - ctx context.Context
+//   - in standalone.Input
 func (_e *MockInterface_Expecter) Do(ctx interface{}, in interface{}) *MockInterface_Do_Call {
 	return &MockInterface_Do_Call{Call: _e.mock.On("Do", ctx, in)}
 }
 
 func (_c *MockInterface_Do_Call) Run(run func(ctx context.Context, in standalone.Input)) *MockInterface_Do_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(standalone.Input))
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 standalone.Input
+		if args[1] != nil {
+			arg1 = args[1].(standalone.Input)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }