pomerium/pkg/ssh/mock/mock_auth_interface.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/pomerium/pomerium/pkg/ssh (interfaces: AuthInterface)
//
// Generated by this command:
//
//	mockgen -typed . AuthInterface
//

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

import (
	context "context"
	reflect "reflect"

	ssh "github.com/pomerium/envoy-custom/api/extensions/filters/network/ssh"
	ssh0 "github.com/pomerium/pomerium/pkg/ssh"
	gomock "go.uber.org/mock/gomock"
)

// MockAuthInterface is a mock of AuthInterface interface.
type MockAuthInterface struct {
	ctrl     *gomock.Controller
	recorder *MockAuthInterfaceMockRecorder
	isgomock struct{}
}

// MockAuthInterfaceMockRecorder is the mock recorder for MockAuthInterface.
type MockAuthInterfaceMockRecorder struct {
	mock *MockAuthInterface
}

// NewMockAuthInterface creates a new mock instance.
func NewMockAuthInterface(ctrl *gomock.Controller) *MockAuthInterface {
	mock := &MockAuthInterface{ctrl: ctrl}
	mock.recorder = &MockAuthInterfaceMockRecorder{mock}
	return mock
}

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

// DeleteSession mocks base method.
func (m *MockAuthInterface) DeleteSession(ctx context.Context, info ssh0.StreamAuthInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSession", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSession indicates an expected call of DeleteSession.
func (mr *MockAuthInterfaceMockRecorder) DeleteSession(ctx, info any) *MockAuthInterfaceDeleteSessionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSession", reflect.TypeOf((*MockAuthInterface)(nil).DeleteSession), ctx, info)
	return &MockAuthInterfaceDeleteSessionCall{Call: call}
}

// MockAuthInterfaceDeleteSessionCall wrap *gomock.Call
type MockAuthInterfaceDeleteSessionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAuthInterfaceDeleteSessionCall) Return(arg0 error) *MockAuthInterfaceDeleteSessionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAuthInterfaceDeleteSessionCall) Do(f func(context.Context, ssh0.StreamAuthInfo) error) *MockAuthInterfaceDeleteSessionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAuthInterfaceDeleteSessionCall) DoAndReturn(f func(context.Context, ssh0.StreamAuthInfo) error) *MockAuthInterfaceDeleteSessionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EvaluateDelayed mocks base method.
func (m *MockAuthInterface) EvaluateDelayed(ctx context.Context, info ssh0.StreamAuthInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EvaluateDelayed", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// EvaluateDelayed indicates an expected call of EvaluateDelayed.
func (mr *MockAuthInterfaceMockRecorder) EvaluateDelayed(ctx, info any) *MockAuthInterfaceEvaluateDelayedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvaluateDelayed", reflect.TypeOf((*MockAuthInterface)(nil).EvaluateDelayed), ctx, info)
	return &MockAuthInterfaceEvaluateDelayedCall{Call: call}
}

// MockAuthInterfaceEvaluateDelayedCall wrap *gomock.Call
type MockAuthInterfaceEvaluateDelayedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAuthInterfaceEvaluateDelayedCall) Return(arg0 error) *MockAuthInterfaceEvaluateDelayedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAuthInterfaceEvaluateDelayedCall) Do(f func(context.Context, ssh0.StreamAuthInfo) error) *MockAuthInterfaceEvaluateDelayedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAuthInterfaceEvaluateDelayedCall) DoAndReturn(f func(context.Context, ssh0.StreamAuthInfo) error) *MockAuthInterfaceEvaluateDelayedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FormatSession mocks base method.
func (m *MockAuthInterface) FormatSession(ctx context.Context, info ssh0.StreamAuthInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FormatSession", ctx, info)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FormatSession indicates an expected call of FormatSession.
func (mr *MockAuthInterfaceMockRecorder) FormatSession(ctx, info any) *MockAuthInterfaceFormatSessionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FormatSession", reflect.TypeOf((*MockAuthInterface)(nil).FormatSession), ctx, info)
	return &MockAuthInterfaceFormatSessionCall{Call: call}
}

// MockAuthInterfaceFormatSessionCall wrap *gomock.Call
type MockAuthInterfaceFormatSessionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAuthInterfaceFormatSessionCall) Return(arg0 []byte, arg1 error) *MockAuthInterfaceFormatSessionCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAuthInterfaceFormatSessionCall) Do(f func(context.Context, ssh0.StreamAuthInfo) ([]byte, error)) *MockAuthInterfaceFormatSessionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAuthInterfaceFormatSessionCall) DoAndReturn(f func(context.Context, ssh0.StreamAuthInfo) ([]byte, error)) *MockAuthInterfaceFormatSessionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// HandleKeyboardInteractiveMethodRequest mocks base method.
func (m *MockAuthInterface) HandleKeyboardInteractiveMethodRequest(ctx context.Context, info ssh0.StreamAuthInfo, req *ssh.KeyboardInteractiveMethodRequest, querier ssh0.KeyboardInteractiveQuerier) (ssh0.KeyboardInteractiveAuthMethodResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleKeyboardInteractiveMethodRequest", ctx, info, req, querier)
	ret0, _ := ret[0].(ssh0.KeyboardInteractiveAuthMethodResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleKeyboardInteractiveMethodRequest indicates an expected call of HandleKeyboardInteractiveMethodRequest.
func (mr *MockAuthInterfaceMockRecorder) HandleKeyboardInteractiveMethodRequest(ctx, info, req, querier any) *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleKeyboardInteractiveMethodRequest", reflect.TypeOf((*MockAuthInterface)(nil).HandleKeyboardInteractiveMethodRequest), ctx, info, req, querier)
	return &MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall{Call: call}
}

// MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall wrap *gomock.Call
type MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall) Return(arg0 ssh0.KeyboardInteractiveAuthMethodResponse, arg1 error) *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall) Do(f func(context.Context, ssh0.StreamAuthInfo, *ssh.KeyboardInteractiveMethodRequest, ssh0.KeyboardInteractiveQuerier) (ssh0.KeyboardInteractiveAuthMethodResponse, error)) *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall) DoAndReturn(f func(context.Context, ssh0.StreamAuthInfo, *ssh.KeyboardInteractiveMethodRequest, ssh0.KeyboardInteractiveQuerier) (ssh0.KeyboardInteractiveAuthMethodResponse, error)) *MockAuthInterfaceHandleKeyboardInteractiveMethodRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// HandlePublicKeyMethodRequest mocks base method.
func (m *MockAuthInterface) HandlePublicKeyMethodRequest(ctx context.Context, info ssh0.StreamAuthInfo, req *ssh.PublicKeyMethodRequest) (ssh0.PublicKeyAuthMethodResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandlePublicKeyMethodRequest", ctx, info, req)
	ret0, _ := ret[0].(ssh0.PublicKeyAuthMethodResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandlePublicKeyMethodRequest indicates an expected call of HandlePublicKeyMethodRequest.
func (mr *MockAuthInterfaceMockRecorder) HandlePublicKeyMethodRequest(ctx, info, req any) *MockAuthInterfaceHandlePublicKeyMethodRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePublicKeyMethodRequest", reflect.TypeOf((*MockAuthInterface)(nil).HandlePublicKeyMethodRequest), ctx, info, req)
	return &MockAuthInterfaceHandlePublicKeyMethodRequestCall{Call: call}
}

// MockAuthInterfaceHandlePublicKeyMethodRequestCall wrap *gomock.Call
type MockAuthInterfaceHandlePublicKeyMethodRequestCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAuthInterfaceHandlePublicKeyMethodRequestCall) Return(arg0 ssh0.PublicKeyAuthMethodResponse, arg1 error) *MockAuthInterfaceHandlePublicKeyMethodRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAuthInterfaceHandlePublicKeyMethodRequestCall) Do(f func(context.Context, ssh0.StreamAuthInfo, *ssh.PublicKeyMethodRequest) (ssh0.PublicKeyAuthMethodResponse, error)) *MockAuthInterfaceHandlePublicKeyMethodRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAuthInterfaceHandlePublicKeyMethodRequestCall) DoAndReturn(f func(context.Context, ssh0.StreamAuthInfo, *ssh.PublicKeyMethodRequest) (ssh0.PublicKeyAuthMethodResponse, error)) *MockAuthInterfaceHandlePublicKeyMethodRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}