Documentation
¶
Index ¶
- Variables
- func ClientCerts(mocked ...[]byte) func() (*x509.CertPool, error)
- func RegisterServiceServerOption(f func(grpc.ServiceRegistrar)) grpc.ServerOption
- func Server(srv testgrpc.TestServiceServer, keyFile, certFile []byte) (func(), error)
- func TokenSource(token oauth2.TokenSource) ...
- type GRPCServer
- type IDTokenStub
- type MockConnPool
- type MockConnPool_Close_Call
- type MockConnPool_Expecter
- type MockConnPool_Open_Call
- func (_c *MockConnPool_Open_Call) Return(_a0 *grpc.ClientConn, _a1 error) *MockConnPool_Open_Call
- func (_c *MockConnPool_Open_Call) Run(run func(ctx context.Context, host string, port int, protocol arpc.Protocol)) *MockConnPool_Open_Call
- func (_c *MockConnPool_Open_Call) RunAndReturn(...) *MockConnPool_Open_Call
- type MockErrorHandler
- func (_m *MockErrorHandler) As(target interface{}, code codes.Code) arpc.ErrorHandler
- func (_m *MockErrorHandler) AsW(target interface{}, code codes.Code, wrap error) arpc.ErrorHandler
- func (_m *MockErrorHandler) AsWF(target interface{}, code codes.Code, format string, args ...interface{}) arpc.ErrorHandler
- func (_m *MockErrorHandler) EXPECT() *MockErrorHandler_Expecter
- func (_m *MockErrorHandler) Handle(err error) error
- func (_m *MockErrorHandler) Is(target error, code codes.Code) arpc.ErrorHandler
- func (_m *MockErrorHandler) IsW(target error, code codes.Code, wrap error) arpc.ErrorHandler
- func (_m *MockErrorHandler) IsWF(target error, code codes.Code, format string, args ...interface{}) arpc.ErrorHandler
- func (_m *MockErrorHandler) Test(caseFn func(error) (error, bool)) arpc.ErrorHandler
- type MockErrorHandler_AsWF_Call
- func (_c *MockErrorHandler_AsWF_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_AsWF_Call
- func (_c *MockErrorHandler_AsWF_Call) Run(...) *MockErrorHandler_AsWF_Call
- func (_c *MockErrorHandler_AsWF_Call) RunAndReturn(run func(interface{}, codes.Code, string, ...interface{}) arpc.ErrorHandler) *MockErrorHandler_AsWF_Call
- type MockErrorHandler_AsW_Call
- func (_c *MockErrorHandler_AsW_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_AsW_Call
- func (_c *MockErrorHandler_AsW_Call) Run(run func(target interface{}, code codes.Code, wrap error)) *MockErrorHandler_AsW_Call
- func (_c *MockErrorHandler_AsW_Call) RunAndReturn(run func(interface{}, codes.Code, error) arpc.ErrorHandler) *MockErrorHandler_AsW_Call
- type MockErrorHandler_As_Call
- func (_c *MockErrorHandler_As_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_As_Call
- func (_c *MockErrorHandler_As_Call) Run(run func(target interface{}, code codes.Code)) *MockErrorHandler_As_Call
- func (_c *MockErrorHandler_As_Call) RunAndReturn(run func(interface{}, codes.Code) arpc.ErrorHandler) *MockErrorHandler_As_Call
- type MockErrorHandler_Expecter
- func (_e *MockErrorHandler_Expecter) As(target interface{}, code interface{}) *MockErrorHandler_As_Call
- func (_e *MockErrorHandler_Expecter) AsW(target interface{}, code interface{}, wrap interface{}) *MockErrorHandler_AsW_Call
- func (_e *MockErrorHandler_Expecter) AsWF(target interface{}, code interface{}, format interface{}, args ...interface{}) *MockErrorHandler_AsWF_Call
- func (_e *MockErrorHandler_Expecter) Handle(err interface{}) *MockErrorHandler_Handle_Call
- func (_e *MockErrorHandler_Expecter) Is(target interface{}, code interface{}) *MockErrorHandler_Is_Call
- func (_e *MockErrorHandler_Expecter) IsW(target interface{}, code interface{}, wrap interface{}) *MockErrorHandler_IsW_Call
- func (_e *MockErrorHandler_Expecter) IsWF(target interface{}, code interface{}, format interface{}, args ...interface{}) *MockErrorHandler_IsWF_Call
- func (_e *MockErrorHandler_Expecter) Test(caseFn interface{}) *MockErrorHandler_Test_Call
- type MockErrorHandler_Handle_Call
- type MockErrorHandler_IsWF_Call
- func (_c *MockErrorHandler_IsWF_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_IsWF_Call
- func (_c *MockErrorHandler_IsWF_Call) Run(run func(target error, code codes.Code, format string, args ...interface{})) *MockErrorHandler_IsWF_Call
- func (_c *MockErrorHandler_IsWF_Call) RunAndReturn(run func(error, codes.Code, string, ...interface{}) arpc.ErrorHandler) *MockErrorHandler_IsWF_Call
- type MockErrorHandler_IsW_Call
- func (_c *MockErrorHandler_IsW_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_IsW_Call
- func (_c *MockErrorHandler_IsW_Call) Run(run func(target error, code codes.Code, wrap error)) *MockErrorHandler_IsW_Call
- func (_c *MockErrorHandler_IsW_Call) RunAndReturn(run func(error, codes.Code, error) arpc.ErrorHandler) *MockErrorHandler_IsW_Call
- type MockErrorHandler_Is_Call
- func (_c *MockErrorHandler_Is_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_Is_Call
- func (_c *MockErrorHandler_Is_Call) Run(run func(target error, code codes.Code)) *MockErrorHandler_Is_Call
- func (_c *MockErrorHandler_Is_Call) RunAndReturn(run func(error, codes.Code) arpc.ErrorHandler) *MockErrorHandler_Is_Call
- type MockErrorHandler_Test_Call
- func (_c *MockErrorHandler_Test_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_Test_Call
- func (_c *MockErrorHandler_Test_Call) Run(run func(caseFn func(error) (error, bool))) *MockErrorHandler_Test_Call
- func (_c *MockErrorHandler_Test_Call) RunAndReturn(run func(func(error) (error, bool)) arpc.ErrorHandler) *MockErrorHandler_Test_Call
- type MockExecService
- type MockExecService_Exec_Call
- func (_c *MockExecService_Exec_Call[In, Out]) Return(_a0 Out, _a1 error) *MockExecService_Exec_Call[In, Out]
- func (_c *MockExecService_Exec_Call[In, Out]) Run(run func(ctx context.Context, data In)) *MockExecService_Exec_Call[In, Out]
- func (_c *MockExecService_Exec_Call[In, Out]) RunAndReturn(run func(context.Context, In) (Out, error)) *MockExecService_Exec_Call[In, Out]
- type MockExecService_Expecter
- type MockGRPCCallback
- type MockGRPCCallback_Execute_Call
- func (_c *MockGRPCCallback_Execute_Call[In, Out]) Return(_a0 Out, _a1 error) *MockGRPCCallback_Execute_Call[In, Out]
- func (_c *MockGRPCCallback_Execute_Call[In, Out]) Run(run func(ctx context.Context, in In)) *MockGRPCCallback_Execute_Call[In, Out]
- func (_c *MockGRPCCallback_Execute_Call[In, Out]) RunAndReturn(run func(context.Context, In) (Out, error)) *MockGRPCCallback_Execute_Call[In, Out]
- type MockGRPCCallback_Expecter
- type MockGRPCServer
- type MockGRPCServer_Expecter
- func (_e *MockGRPCServer_Expecter) GracefulStop() *MockGRPCServer_GracefulStop_Call
- func (_e *MockGRPCServer_Expecter) RegisterService(desc interface{}, impl interface{}) *MockGRPCServer_RegisterService_Call
- func (_e *MockGRPCServer_Expecter) Serve(_a0 interface{}) *MockGRPCServer_Serve_Call
- func (_e *MockGRPCServer_Expecter) Stop() *MockGRPCServer_Stop_Call
- type MockGRPCServer_GracefulStop_Call
- type MockGRPCServer_RegisterService_Call
- func (_c *MockGRPCServer_RegisterService_Call) Return() *MockGRPCServer_RegisterService_Call
- func (_c *MockGRPCServer_RegisterService_Call) Run(run func(desc *grpc.ServiceDesc, impl interface{})) *MockGRPCServer_RegisterService_Call
- func (_c *MockGRPCServer_RegisterService_Call) RunAndReturn(run func(*grpc.ServiceDesc, interface{})) *MockGRPCServer_RegisterService_Call
- type MockGRPCServer_Serve_Call
- type MockGRPCServer_Stop_Call
- type MockProtoConverter
- type MockProtoConverter_Expecter
- type MockProtoConverter_FromProto_Call
- func (_c *MockProtoConverter_FromProto_Call[Proto, Entity]) Return(_a0 Entity) *MockProtoConverter_FromProto_Call[Proto, Entity]
- func (_c *MockProtoConverter_FromProto_Call[Proto, Entity]) Run(run func(src Proto)) *MockProtoConverter_FromProto_Call[Proto, Entity]
- func (_c *MockProtoConverter_FromProto_Call[Proto, Entity]) RunAndReturn(run func(Proto) Entity) *MockProtoConverter_FromProto_Call[Proto, Entity]
- type MockProtoConverter_ToProto_Call
- func (_c *MockProtoConverter_ToProto_Call[Proto, Entity]) Return(_a0 Proto) *MockProtoConverter_ToProto_Call[Proto, Entity]
- func (_c *MockProtoConverter_ToProto_Call[Proto, Entity]) Run(run func(src Entity)) *MockProtoConverter_ToProto_Call[Proto, Entity]
- func (_c *MockProtoConverter_ToProto_Call[Proto, Entity]) RunAndReturn(run func(Entity) Proto) *MockProtoConverter_ToProto_Call[Proto, Entity]
- type StubServer
- func (ss *StubServer) EmptyCall(ctx context.Context, in *testgrpc.Empty) (*testgrpc.Empty, error)
- func (ss *StubServer) FullDuplexCall(stream testgrpc.TestService_FullDuplexCallServer) error
- func (ss *StubServer) NewServiceConfig(sc string)
- func (ss *StubServer) Start(sopts []grpc.ServerOption, dopts ...grpc.DialOption) error
- func (ss *StubServer) StartClient(dopts ...grpc.DialOption) error
- func (ss *StubServer) StartHandlerServer(sopts ...grpc.ServerOption) error
- func (ss *StubServer) StartServer(sopts ...grpc.ServerOption) error
- func (ss *StubServer) Stop()
- func (ss *StubServer) UnaryCall(ctx context.Context, in *testgrpc.SimpleRequest) (*testgrpc.SimpleResponse, error)
Constants ¶
This section is empty.
Variables ¶
var DefaultToken = &oauth2.Token{ AccessToken: "secret-access-token", TokenType: "custom-token-type", RefreshToken: "refresh-token", Expiry: time.Now().Add(time.Hour), ExpiresIn: 999999999, }
var ErrAppendCert = errors.New("failed to append certificate to default pool")
Functions ¶
func RegisterServiceServerOption ¶
func RegisterServiceServerOption(f func(grpc.ServiceRegistrar)) grpc.ServerOption
RegisterServiceServerOption returns a ServerOption that will run f() in Start or StartServer with the grpc.Server created before serving. This allows other services to be registered on the test server (e.g. ORCA, health, or reflection).
func TokenSource ¶
func TokenSource( token oauth2.TokenSource, ) func(ctx context.Context, audience string, opts ...idtoken.ClientOption) (oauth2.TokenSource, error)
Types ¶
type GRPCServer ¶
type GRPCServer interface { grpc.ServiceRegistrar Stop() GracefulStop() Serve(net.Listener) error }
GRPCServer is an interface that groups methods implemented by a grpc.Server or an xds.GRPCServer that are used by the StubServer.
type IDTokenStub ¶
type IDTokenStub struct {
oauth2.TokenSource
}
type MockConnPool ¶
MockConnPool is an autogenerated mock type for the ConnPool type
func NewMockConnPool ¶
func NewMockConnPool(t interface { mock.TestingT Cleanup(func()) }) *MockConnPool
NewMockConnPool creates a new instance of MockConnPool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.
func (*MockConnPool) Close ¶
func (_m *MockConnPool) Close()
Close provides a mock function with given fields:
func (*MockConnPool) EXPECT ¶
func (_m *MockConnPool) EXPECT() *MockConnPool_Expecter
type MockConnPool_Close_Call ¶
MockConnPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
func (*MockConnPool_Close_Call) Return ¶
func (_c *MockConnPool_Close_Call) Return() *MockConnPool_Close_Call
func (*MockConnPool_Close_Call) Run ¶
func (_c *MockConnPool_Close_Call) Run(run func()) *MockConnPool_Close_Call
func (*MockConnPool_Close_Call) RunAndReturn ¶
func (_c *MockConnPool_Close_Call) RunAndReturn(run func()) *MockConnPool_Close_Call
type MockConnPool_Expecter ¶
type MockConnPool_Expecter struct {
// contains filtered or unexported fields
}
func (*MockConnPool_Expecter) Close ¶
func (_e *MockConnPool_Expecter) Close() *MockConnPool_Close_Call
Close is a helper method to define mock.On call
func (*MockConnPool_Expecter) Open ¶
func (_e *MockConnPool_Expecter) Open(ctx interface{}, host interface{}, port interface{}, protocol interface{}) *MockConnPool_Open_Call
Open is a helper method to define mock.On call
- ctx context.Context
- host string
- port int
- protocol arpc.Protocol
type MockConnPool_Open_Call ¶
MockConnPool_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
func (*MockConnPool_Open_Call) Return ¶
func (_c *MockConnPool_Open_Call) Return(_a0 *grpc.ClientConn, _a1 error) *MockConnPool_Open_Call
func (*MockConnPool_Open_Call) Run ¶
func (_c *MockConnPool_Open_Call) Run(run func(ctx context.Context, host string, port int, protocol arpc.Protocol)) *MockConnPool_Open_Call
func (*MockConnPool_Open_Call) RunAndReturn ¶
func (_c *MockConnPool_Open_Call) RunAndReturn(run func(context.Context, string, int, arpc.Protocol) (*grpc.ClientConn, error)) *MockConnPool_Open_Call
type MockErrorHandler ¶
MockErrorHandler is an autogenerated mock type for the ErrorHandler type
func NewMockErrorHandler ¶
func NewMockErrorHandler(t interface { mock.TestingT Cleanup(func()) }) *MockErrorHandler
NewMockErrorHandler creates a new instance of MockErrorHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.
func (*MockErrorHandler) As ¶
func (_m *MockErrorHandler) As(target interface{}, code codes.Code) arpc.ErrorHandler
As provides a mock function with given fields: target, code
func (*MockErrorHandler) AsW ¶
func (_m *MockErrorHandler) AsW(target interface{}, code codes.Code, wrap error) arpc.ErrorHandler
AsW provides a mock function with given fields: target, code, wrap
func (*MockErrorHandler) AsWF ¶
func (_m *MockErrorHandler) AsWF(target interface{}, code codes.Code, format string, args ...interface{}) arpc.ErrorHandler
AsWF provides a mock function with given fields: target, code, format, args
func (*MockErrorHandler) EXPECT ¶
func (_m *MockErrorHandler) EXPECT() *MockErrorHandler_Expecter
func (*MockErrorHandler) Handle ¶
func (_m *MockErrorHandler) Handle(err error) error
Handle provides a mock function with given fields: err
func (*MockErrorHandler) Is ¶
func (_m *MockErrorHandler) Is(target error, code codes.Code) arpc.ErrorHandler
Is provides a mock function with given fields: target, code
func (*MockErrorHandler) IsW ¶
func (_m *MockErrorHandler) IsW(target error, code codes.Code, wrap error) arpc.ErrorHandler
IsW provides a mock function with given fields: target, code, wrap
func (*MockErrorHandler) IsWF ¶
func (_m *MockErrorHandler) IsWF(target error, code codes.Code, format string, args ...interface{}) arpc.ErrorHandler
IsWF provides a mock function with given fields: target, code, format, args
func (*MockErrorHandler) Test ¶
func (_m *MockErrorHandler) Test(caseFn func(error) (error, bool)) arpc.ErrorHandler
Test provides a mock function with given fields: caseFn
type MockErrorHandler_AsWF_Call ¶
MockErrorHandler_AsWF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AsWF'
func (*MockErrorHandler_AsWF_Call) Return ¶
func (_c *MockErrorHandler_AsWF_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_AsWF_Call
func (*MockErrorHandler_AsWF_Call) Run ¶
func (_c *MockErrorHandler_AsWF_Call) Run(run func(target interface{}, code codes.Code, format string, args ...interface{})) *MockErrorHandler_AsWF_Call
func (*MockErrorHandler_AsWF_Call) RunAndReturn ¶
func (_c *MockErrorHandler_AsWF_Call) RunAndReturn(run func(interface{}, codes.Code, string, ...interface{}) arpc.ErrorHandler) *MockErrorHandler_AsWF_Call
type MockErrorHandler_AsW_Call ¶
MockErrorHandler_AsW_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AsW'
func (*MockErrorHandler_AsW_Call) Return ¶
func (_c *MockErrorHandler_AsW_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_AsW_Call
func (*MockErrorHandler_AsW_Call) Run ¶
func (_c *MockErrorHandler_AsW_Call) Run(run func(target interface{}, code codes.Code, wrap error)) *MockErrorHandler_AsW_Call
func (*MockErrorHandler_AsW_Call) RunAndReturn ¶
func (_c *MockErrorHandler_AsW_Call) RunAndReturn(run func(interface{}, codes.Code, error) arpc.ErrorHandler) *MockErrorHandler_AsW_Call
type MockErrorHandler_As_Call ¶
MockErrorHandler_As_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'As'
func (*MockErrorHandler_As_Call) Return ¶
func (_c *MockErrorHandler_As_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_As_Call
func (*MockErrorHandler_As_Call) Run ¶
func (_c *MockErrorHandler_As_Call) Run(run func(target interface{}, code codes.Code)) *MockErrorHandler_As_Call
func (*MockErrorHandler_As_Call) RunAndReturn ¶
func (_c *MockErrorHandler_As_Call) RunAndReturn(run func(interface{}, codes.Code) arpc.ErrorHandler) *MockErrorHandler_As_Call
type MockErrorHandler_Expecter ¶
type MockErrorHandler_Expecter struct {
// contains filtered or unexported fields
}
func (*MockErrorHandler_Expecter) As ¶
func (_e *MockErrorHandler_Expecter) As(target interface{}, code interface{}) *MockErrorHandler_As_Call
As is a helper method to define mock.On call
- target interface{}
- code codes.Code
func (*MockErrorHandler_Expecter) AsW ¶
func (_e *MockErrorHandler_Expecter) AsW(target interface{}, code interface{}, wrap interface{}) *MockErrorHandler_AsW_Call
AsW is a helper method to define mock.On call
- target interface{}
- code codes.Code
- wrap error
func (*MockErrorHandler_Expecter) AsWF ¶
func (_e *MockErrorHandler_Expecter) AsWF(target interface{}, code interface{}, format interface{}, args ...interface{}) *MockErrorHandler_AsWF_Call
AsWF is a helper method to define mock.On call
- target interface{}
- code codes.Code
- format string
- args ...interface{}
func (*MockErrorHandler_Expecter) Handle ¶
func (_e *MockErrorHandler_Expecter) Handle(err interface{}) *MockErrorHandler_Handle_Call
Handle is a helper method to define mock.On call
- err error
func (*MockErrorHandler_Expecter) Is ¶
func (_e *MockErrorHandler_Expecter) Is(target interface{}, code interface{}) *MockErrorHandler_Is_Call
Is is a helper method to define mock.On call
- target error
- code codes.Code
func (*MockErrorHandler_Expecter) IsW ¶
func (_e *MockErrorHandler_Expecter) IsW(target interface{}, code interface{}, wrap interface{}) *MockErrorHandler_IsW_Call
IsW is a helper method to define mock.On call
- target error
- code codes.Code
- wrap error
func (*MockErrorHandler_Expecter) IsWF ¶
func (_e *MockErrorHandler_Expecter) IsWF(target interface{}, code interface{}, format interface{}, args ...interface{}) *MockErrorHandler_IsWF_Call
IsWF is a helper method to define mock.On call
- target error
- code codes.Code
- format string
- args ...interface{}
func (*MockErrorHandler_Expecter) Test ¶
func (_e *MockErrorHandler_Expecter) Test(caseFn interface{}) *MockErrorHandler_Test_Call
Test is a helper method to define mock.On call
- caseFn func(error)(error , bool)
type MockErrorHandler_Handle_Call ¶
MockErrorHandler_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle'
func (*MockErrorHandler_Handle_Call) Return ¶
func (_c *MockErrorHandler_Handle_Call) Return(_a0 error) *MockErrorHandler_Handle_Call
func (*MockErrorHandler_Handle_Call) Run ¶
func (_c *MockErrorHandler_Handle_Call) Run(run func(err error)) *MockErrorHandler_Handle_Call
func (*MockErrorHandler_Handle_Call) RunAndReturn ¶
func (_c *MockErrorHandler_Handle_Call) RunAndReturn(run func(error) error) *MockErrorHandler_Handle_Call
type MockErrorHandler_IsWF_Call ¶
MockErrorHandler_IsWF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsWF'
func (*MockErrorHandler_IsWF_Call) Return ¶
func (_c *MockErrorHandler_IsWF_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_IsWF_Call
func (*MockErrorHandler_IsWF_Call) Run ¶
func (_c *MockErrorHandler_IsWF_Call) Run(run func(target error, code codes.Code, format string, args ...interface{})) *MockErrorHandler_IsWF_Call
func (*MockErrorHandler_IsWF_Call) RunAndReturn ¶
func (_c *MockErrorHandler_IsWF_Call) RunAndReturn(run func(error, codes.Code, string, ...interface{}) arpc.ErrorHandler) *MockErrorHandler_IsWF_Call
type MockErrorHandler_IsW_Call ¶
MockErrorHandler_IsW_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsW'
func (*MockErrorHandler_IsW_Call) Return ¶
func (_c *MockErrorHandler_IsW_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_IsW_Call
func (*MockErrorHandler_IsW_Call) Run ¶
func (_c *MockErrorHandler_IsW_Call) Run(run func(target error, code codes.Code, wrap error)) *MockErrorHandler_IsW_Call
func (*MockErrorHandler_IsW_Call) RunAndReturn ¶
func (_c *MockErrorHandler_IsW_Call) RunAndReturn(run func(error, codes.Code, error) arpc.ErrorHandler) *MockErrorHandler_IsW_Call
type MockErrorHandler_Is_Call ¶
MockErrorHandler_Is_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Is'
func (*MockErrorHandler_Is_Call) Return ¶
func (_c *MockErrorHandler_Is_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_Is_Call
func (*MockErrorHandler_Is_Call) Run ¶
func (_c *MockErrorHandler_Is_Call) Run(run func(target error, code codes.Code)) *MockErrorHandler_Is_Call
func (*MockErrorHandler_Is_Call) RunAndReturn ¶
func (_c *MockErrorHandler_Is_Call) RunAndReturn(run func(error, codes.Code) arpc.ErrorHandler) *MockErrorHandler_Is_Call
type MockErrorHandler_Test_Call ¶
MockErrorHandler_Test_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Test'
func (*MockErrorHandler_Test_Call) Return ¶
func (_c *MockErrorHandler_Test_Call) Return(_a0 arpc.ErrorHandler) *MockErrorHandler_Test_Call
func (*MockErrorHandler_Test_Call) Run ¶
func (_c *MockErrorHandler_Test_Call) Run(run func(caseFn func(error) (error, bool))) *MockErrorHandler_Test_Call
func (*MockErrorHandler_Test_Call) RunAndReturn ¶
func (_c *MockErrorHandler_Test_Call) RunAndReturn(run func(func(error) (error, bool)) arpc.ErrorHandler) *MockErrorHandler_Test_Call
type MockExecService ¶
MockExecService is an autogenerated mock type for the ExecService type
func NewMockExecService ¶
func NewMockExecService[In interface{}, Out interface{}](t interface { mock.TestingT Cleanup(func()) }) *MockExecService[In, Out]
NewMockExecService creates a new instance of MockExecService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.
func (*MockExecService[In, Out]) EXPECT ¶
func (_m *MockExecService[In, Out]) EXPECT() *MockExecService_Expecter[In, Out]
type MockExecService_Exec_Call ¶
MockExecService_Exec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exec'
func (*MockExecService_Exec_Call[In, Out]) Return ¶
func (_c *MockExecService_Exec_Call[In, Out]) Return(_a0 Out, _a1 error) *MockExecService_Exec_Call[In, Out]
func (*MockExecService_Exec_Call[In, Out]) Run ¶
func (_c *MockExecService_Exec_Call[In, Out]) Run(run func(ctx context.Context, data In)) *MockExecService_Exec_Call[In, Out]
func (*MockExecService_Exec_Call[In, Out]) RunAndReturn ¶
func (_c *MockExecService_Exec_Call[In, Out]) RunAndReturn(run func(context.Context, In) (Out, error)) *MockExecService_Exec_Call[In, Out]
type MockExecService_Expecter ¶
type MockExecService_Expecter[In interface{}, Out interface{}] struct {
// contains filtered or unexported fields
}
func (*MockExecService_Expecter[In, Out]) Exec ¶
func (_e *MockExecService_Expecter[In, Out]) Exec(ctx interface{}, data interface{}) *MockExecService_Exec_Call[In, Out]
Exec is a helper method to define mock.On call
- ctx context.Context
- data In
type MockGRPCCallback ¶
MockGRPCCallback is an autogenerated mock type for the GRPCCallback type
func NewMockGRPCCallback ¶
func NewMockGRPCCallback[In interface{}, Out interface{}](t interface { mock.TestingT Cleanup(func()) }) *MockGRPCCallback[In, Out]
NewMockGRPCCallback creates a new instance of MockGRPCCallback. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.
func (*MockGRPCCallback[In, Out]) EXPECT ¶
func (_m *MockGRPCCallback[In, Out]) EXPECT() *MockGRPCCallback_Expecter[In, Out]
type MockGRPCCallback_Execute_Call ¶
MockGRPCCallback_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
func (*MockGRPCCallback_Execute_Call[In, Out]) Return ¶
func (_c *MockGRPCCallback_Execute_Call[In, Out]) Return(_a0 Out, _a1 error) *MockGRPCCallback_Execute_Call[In, Out]
func (*MockGRPCCallback_Execute_Call[In, Out]) Run ¶
func (_c *MockGRPCCallback_Execute_Call[In, Out]) Run(run func(ctx context.Context, in In)) *MockGRPCCallback_Execute_Call[In, Out]
func (*MockGRPCCallback_Execute_Call[In, Out]) RunAndReturn ¶
func (_c *MockGRPCCallback_Execute_Call[In, Out]) RunAndReturn(run func(context.Context, In) (Out, error)) *MockGRPCCallback_Execute_Call[In, Out]
type MockGRPCCallback_Expecter ¶
type MockGRPCCallback_Expecter[In interface{}, Out interface{}] struct {
// contains filtered or unexported fields
}
func (*MockGRPCCallback_Expecter[In, Out]) Execute ¶
func (_e *MockGRPCCallback_Expecter[In, Out]) Execute(ctx interface{}, in interface{}) *MockGRPCCallback_Execute_Call[In, Out]
Execute is a helper method to define mock.On call
- ctx context.Context
- in In
type MockGRPCServer ¶
MockGRPCServer is an autogenerated mock type for the GRPCServer type
func NewMockGRPCServer ¶
func NewMockGRPCServer(t interface { mock.TestingT Cleanup(func()) }) *MockGRPCServer
NewMockGRPCServer creates a new instance of MockGRPCServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.
func (*MockGRPCServer) EXPECT ¶
func (_m *MockGRPCServer) EXPECT() *MockGRPCServer_Expecter
func (*MockGRPCServer) GracefulStop ¶
func (_m *MockGRPCServer) GracefulStop()
GracefulStop provides a mock function with given fields:
func (*MockGRPCServer) RegisterService ¶
func (_m *MockGRPCServer) RegisterService(desc *grpc.ServiceDesc, impl interface{})
RegisterService provides a mock function with given fields: desc, impl
func (*MockGRPCServer) Serve ¶
func (_m *MockGRPCServer) Serve(_a0 net.Listener) error
Serve provides a mock function with given fields: _a0
func (*MockGRPCServer) Stop ¶
func (_m *MockGRPCServer) Stop()
Stop provides a mock function with given fields:
type MockGRPCServer_Expecter ¶
type MockGRPCServer_Expecter struct {
// contains filtered or unexported fields
}
func (*MockGRPCServer_Expecter) GracefulStop ¶
func (_e *MockGRPCServer_Expecter) GracefulStop() *MockGRPCServer_GracefulStop_Call
GracefulStop is a helper method to define mock.On call
func (*MockGRPCServer_Expecter) RegisterService ¶
func (_e *MockGRPCServer_Expecter) RegisterService(desc interface{}, impl interface{}) *MockGRPCServer_RegisterService_Call
RegisterService is a helper method to define mock.On call
- desc *grpc.ServiceDesc
- impl interface{}
func (*MockGRPCServer_Expecter) Serve ¶
func (_e *MockGRPCServer_Expecter) Serve(_a0 interface{}) *MockGRPCServer_Serve_Call
Serve is a helper method to define mock.On call
- _a0 net.Listener
func (*MockGRPCServer_Expecter) Stop ¶
func (_e *MockGRPCServer_Expecter) Stop() *MockGRPCServer_Stop_Call
Stop is a helper method to define mock.On call
type MockGRPCServer_GracefulStop_Call ¶
MockGRPCServer_GracefulStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GracefulStop'
func (*MockGRPCServer_GracefulStop_Call) Return ¶
func (_c *MockGRPCServer_GracefulStop_Call) Return() *MockGRPCServer_GracefulStop_Call
func (*MockGRPCServer_GracefulStop_Call) Run ¶
func (_c *MockGRPCServer_GracefulStop_Call) Run(run func()) *MockGRPCServer_GracefulStop_Call
func (*MockGRPCServer_GracefulStop_Call) RunAndReturn ¶
func (_c *MockGRPCServer_GracefulStop_Call) RunAndReturn(run func()) *MockGRPCServer_GracefulStop_Call
type MockGRPCServer_RegisterService_Call ¶
MockGRPCServer_RegisterService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterService'
func (*MockGRPCServer_RegisterService_Call) Return ¶
func (_c *MockGRPCServer_RegisterService_Call) Return() *MockGRPCServer_RegisterService_Call
func (*MockGRPCServer_RegisterService_Call) Run ¶
func (_c *MockGRPCServer_RegisterService_Call) Run(run func(desc *grpc.ServiceDesc, impl interface{})) *MockGRPCServer_RegisterService_Call
func (*MockGRPCServer_RegisterService_Call) RunAndReturn ¶
func (_c *MockGRPCServer_RegisterService_Call) RunAndReturn(run func(*grpc.ServiceDesc, interface{})) *MockGRPCServer_RegisterService_Call
type MockGRPCServer_Serve_Call ¶
MockGRPCServer_Serve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Serve'
func (*MockGRPCServer_Serve_Call) Return ¶
func (_c *MockGRPCServer_Serve_Call) Return(_a0 error) *MockGRPCServer_Serve_Call
func (*MockGRPCServer_Serve_Call) Run ¶
func (_c *MockGRPCServer_Serve_Call) Run(run func(_a0 net.Listener)) *MockGRPCServer_Serve_Call
func (*MockGRPCServer_Serve_Call) RunAndReturn ¶
func (_c *MockGRPCServer_Serve_Call) RunAndReturn(run func(net.Listener) error) *MockGRPCServer_Serve_Call
type MockGRPCServer_Stop_Call ¶
MockGRPCServer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
func (*MockGRPCServer_Stop_Call) Return ¶
func (_c *MockGRPCServer_Stop_Call) Return() *MockGRPCServer_Stop_Call
func (*MockGRPCServer_Stop_Call) Run ¶
func (_c *MockGRPCServer_Stop_Call) Run(run func()) *MockGRPCServer_Stop_Call
func (*MockGRPCServer_Stop_Call) RunAndReturn ¶
func (_c *MockGRPCServer_Stop_Call) RunAndReturn(run func()) *MockGRPCServer_Stop_Call
type MockProtoConverter ¶
type MockProtoConverter[Proto comparable, Entity comparable] struct { mock.Mock }
MockProtoConverter is an autogenerated mock type for the ProtoConverter type
func NewMockProtoConverter ¶
func NewMockProtoConverter[Proto comparable, Entity comparable](t interface { mock.TestingT Cleanup(func()) }) *MockProtoConverter[Proto, Entity]
NewMockProtoConverter creates a new instance of MockProtoConverter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.
func (*MockProtoConverter[Proto, Entity]) EXPECT ¶
func (_m *MockProtoConverter[Proto, Entity]) EXPECT() *MockProtoConverter_Expecter[Proto, Entity]
func (*MockProtoConverter[Proto, Entity]) FromProto ¶
func (_m *MockProtoConverter[Proto, Entity]) FromProto(src Proto) Entity
FromProto provides a mock function with given fields: src
func (*MockProtoConverter[Proto, Entity]) ToProto ¶
func (_m *MockProtoConverter[Proto, Entity]) ToProto(src Entity) Proto
ToProto provides a mock function with given fields: src
type MockProtoConverter_Expecter ¶
type MockProtoConverter_Expecter[Proto comparable, Entity comparable] struct { // contains filtered or unexported fields }
func (*MockProtoConverter_Expecter[Proto, Entity]) FromProto ¶
func (_e *MockProtoConverter_Expecter[Proto, Entity]) FromProto(src interface{}) *MockProtoConverter_FromProto_Call[Proto, Entity]
FromProto is a helper method to define mock.On call
- src Proto
func (*MockProtoConverter_Expecter[Proto, Entity]) ToProto ¶
func (_e *MockProtoConverter_Expecter[Proto, Entity]) ToProto(src interface{}) *MockProtoConverter_ToProto_Call[Proto, Entity]
ToProto is a helper method to define mock.On call
- src Entity
type MockProtoConverter_FromProto_Call ¶
type MockProtoConverter_FromProto_Call[Proto comparable, Entity comparable] struct { *mock.Call }
MockProtoConverter_FromProto_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FromProto'
func (*MockProtoConverter_FromProto_Call[Proto, Entity]) Return ¶
func (_c *MockProtoConverter_FromProto_Call[Proto, Entity]) Return(_a0 Entity) *MockProtoConverter_FromProto_Call[Proto, Entity]
func (*MockProtoConverter_FromProto_Call[Proto, Entity]) Run ¶
func (_c *MockProtoConverter_FromProto_Call[Proto, Entity]) Run(run func(src Proto)) *MockProtoConverter_FromProto_Call[Proto, Entity]
func (*MockProtoConverter_FromProto_Call[Proto, Entity]) RunAndReturn ¶
func (_c *MockProtoConverter_FromProto_Call[Proto, Entity]) RunAndReturn(run func(Proto) Entity) *MockProtoConverter_FromProto_Call[Proto, Entity]
type MockProtoConverter_ToProto_Call ¶
type MockProtoConverter_ToProto_Call[Proto comparable, Entity comparable] struct { *mock.Call }
MockProtoConverter_ToProto_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToProto'
func (*MockProtoConverter_ToProto_Call[Proto, Entity]) Return ¶
func (_c *MockProtoConverter_ToProto_Call[Proto, Entity]) Return(_a0 Proto) *MockProtoConverter_ToProto_Call[Proto, Entity]
func (*MockProtoConverter_ToProto_Call[Proto, Entity]) Run ¶
func (_c *MockProtoConverter_ToProto_Call[Proto, Entity]) Run(run func(src Entity)) *MockProtoConverter_ToProto_Call[Proto, Entity]
func (*MockProtoConverter_ToProto_Call[Proto, Entity]) RunAndReturn ¶
func (_c *MockProtoConverter_ToProto_Call[Proto, Entity]) RunAndReturn(run func(Entity) Proto) *MockProtoConverter_ToProto_Call[Proto, Entity]
type StubServer ¶
type StubServer struct { // Guarantees we satisfy this interface; panics if unimplemented methods are called. testgrpc.TestServiceServer // Customizable implementations of server handlers. EmptyCallF func(ctx context.Context, in *testgrpc.Empty) (*testgrpc.Empty, error) UnaryCallF func(ctx context.Context, in *testgrpc.SimpleRequest) (*testgrpc.SimpleResponse, error) FullDuplexCallF func(stream testgrpc.TestService_FullDuplexCallServer) error // A client connected to this service the test may use. Created in Start(). Client testgrpc.TestServiceClient CC *grpc.ClientConn // Server to serve this service from. // // If nil, a new grpc.Server is created, listening on the provided Network // and Address fields, or listening using the provided Listener. S GRPCServer // Parameters for Listen and Dial. Defaults will be used if these are empty // before Start. Network string Address string Target string // Custom listener to use for serving. If unspecified, a new listener is // created on a local port. Listener net.Listener // Set automatically if Target == "" R *manual.Resolver // contains filtered or unexported fields }
StubServer is a server that is easy to customize within individual test cases.
func StartTestService ¶
func StartTestService(t *testing.T, server *StubServer, sopts ...grpc.ServerOption) *StubServer
StartTestService spins up a stub server exposing the TestService on a local port. If the passed in server is nil, a stub server that implements only the EmptyCall and UnaryCall RPCs is started.
func (*StubServer) FullDuplexCall ¶
func (ss *StubServer) FullDuplexCall(stream testgrpc.TestService_FullDuplexCallServer) error
FullDuplexCall is the handler for testgrpc.FullDuplexCall
func (*StubServer) NewServiceConfig ¶
func (ss *StubServer) NewServiceConfig(sc string)
NewServiceConfig applies sc to ss.Client using the resolver (if present).
func (*StubServer) Start ¶
func (ss *StubServer) Start(sopts []grpc.ServerOption, dopts ...grpc.DialOption) error
Start starts the server and creates a client connected to it.
func (*StubServer) StartClient ¶
func (ss *StubServer) StartClient(dopts ...grpc.DialOption) error
StartClient creates a client connected to this service that the test may use. The newly created client will be available in the Client field of StubServer.
func (*StubServer) StartHandlerServer ¶
func (ss *StubServer) StartHandlerServer(sopts ...grpc.ServerOption) error
StartHandlerServer only starts an HTTP server with a gRPC server as the handler. It does not create a client to it. Cannot be used in a StubServer that also used StartServer.
func (*StubServer) StartServer ¶
func (ss *StubServer) StartServer(sopts ...grpc.ServerOption) error
StartServer only starts the server. It does not create a client to it. Cannot be used in a StubServer that also used StartHandlerServer.
func (*StubServer) Stop ¶
func (ss *StubServer) Stop()
Stop stops ss and cleans up all resources it consumed.
func (*StubServer) UnaryCall ¶
func (ss *StubServer) UnaryCall(ctx context.Context, in *testgrpc.SimpleRequest) (*testgrpc.SimpleResponse, error)
UnaryCall is the handler for testgrpc.UnaryCall