...

Package testutils

import "google.golang.org/grpc/internal/testutils"
Overview
Index
Subdirectories

Overview ▾

Package testutils contains testing helpers.

Index ▾

Constants
Variables
func AwaitNoStateChange(ctx context.Context, t *testing.T, sc StateChanger, currState connectivity.State)
func AwaitNotState(ctx context.Context, t *testing.T, sc StateChanger, stateDoNotWant connectivity.State)
func AwaitState(ctx context.Context, t *testing.T, sc StateChanger, stateWant connectivity.State)
func IsRoundRobin(want []balancer.SubConn, f func() balancer.SubConn) error
func LocalTCPListener() (net.Listener, error)
func MarshalAny(t *testing.T, m proto.Message) *anypb.Any
func MustParseURL(target string) *url.URL
func NewTestWRR() wrr.WRR
func ParsePort(t *testing.T, addr string) uint32
func StatusErrEqual(err1, err2 error) bool
func StayConnected(ctx context.Context, sc StateChanger)
func SubConnFromPicker(p balancer.Picker) func() balancer.SubConn
type BalancerClientConn
    func NewBalancerClientConn(t *testing.T) *BalancerClientConn
    func (tcc *BalancerClientConn) NewSubConn(a []resolver.Address, o balancer.NewSubConnOptions) (balancer.SubConn, error)
    func (tcc *BalancerClientConn) RemoveSubConn(sc balancer.SubConn)
    func (tcc *BalancerClientConn) ResolveNow(o resolver.ResolveNowOptions)
    func (tcc *BalancerClientConn) Target() string
    func (tcc *BalancerClientConn) UpdateAddresses(sc balancer.SubConn, addrs []resolver.Address)
    func (tcc *BalancerClientConn) UpdateState(bs balancer.State)
    func (tcc *BalancerClientConn) WaitForConnectivityState(ctx context.Context, want connectivity.State) error
    func (tcc *BalancerClientConn) WaitForErrPicker(ctx context.Context) error
    func (tcc *BalancerClientConn) WaitForPicker(ctx context.Context, f func(balancer.Picker) error) error
    func (tcc *BalancerClientConn) WaitForPickerWithErr(ctx context.Context, want error) error
    func (tcc *BalancerClientConn) WaitForRoundRobinPicker(ctx context.Context, want ...balancer.SubConn) error
type Channel
    func NewChannel() *Channel
    func NewChannelWithSize(bufSize int) *Channel
    func (c *Channel) Receive(ctx context.Context) (any, error)
    func (c *Channel) ReceiveOrFail() (any, bool)
    func (c *Channel) Replace(value any)
    func (c *Channel) Send(value any)
    func (c *Channel) SendContext(ctx context.Context, value any) error
    func (c *Channel) SendOrFail(value any) bool
type ConnWrapper
    func (cw *ConnWrapper) Close() error
type FakeHTTPClient
    func (fc *FakeHTTPClient) Do(req *http.Request) (*http.Response, error)
type ListenerWrapper
    func NewListenerWrapper(t *testing.T, lis net.Listener) *ListenerWrapper
    func (l *ListenerWrapper) Accept() (net.Conn, error)
type Logger
type PipeListener
    func NewPipeListener() *PipeListener
    func (p *PipeListener) Accept() (net.Conn, error)
    func (p *PipeListener) Addr() net.Addr
    func (p *PipeListener) Close() error
    func (p *PipeListener) Dialer() func(string, time.Duration) (net.Conn, error)
type ResolverClientConn
    func (t *ResolverClientConn) ParseServiceConfig(jsonSC string) *serviceconfig.ParseResult
    func (t *ResolverClientConn) ReportError(err error)
    func (t *ResolverClientConn) UpdateState(s resolver.State) error
type RestartableListener
    func NewRestartableListener(l net.Listener) *RestartableListener
    func (l *RestartableListener) Accept() (net.Conn, error)
    func (l *RestartableListener) Addr() net.Addr
    func (l *RestartableListener) Close() error
    func (l *RestartableListener) Restart()
    func (l *RestartableListener) Stop()
type StateChanger
type StubStatsHandler
    func (ssh *StubStatsHandler) HandleConn(ctx context.Context, cs stats.ConnStats)
    func (ssh *StubStatsHandler) HandleRPC(ctx context.Context, rs stats.RPCStats)
    func (ssh *StubStatsHandler) TagConn(ctx context.Context, info *stats.ConnTagInfo) context.Context
    func (ssh *StubStatsHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context
type TestConstPicker
    func (tcp *TestConstPicker) Pick(info balancer.PickInfo) (balancer.PickResult, error)
type TestSubConn
    func NewTestSubConn(id string) *TestSubConn
    func (tsc *TestSubConn) Connect()
    func (tsc *TestSubConn) GetOrBuildProducer(balancer.ProducerBuilder) (balancer.Producer, func())
    func (tsc *TestSubConn) Shutdown()
    func (tsc *TestSubConn) String() string
    func (tsc *TestSubConn) UpdateAddresses([]resolver.Address)
    func (tsc *TestSubConn) UpdateState(state balancer.SubConnState)

Package files

balancer.go channel.go http_client.go local_listener.go marshal_any.go parse_port.go parse_url.go pipe_listener.go resolver.go restartable_listener.go state.go status_equal.go stubstatshandler.go wrappers.go wrr.go

Constants

DefaultChanBufferSize is the default buffer size of the underlying channel.

const DefaultChanBufferSize = 1

DefaultHTTPRequestTimeout is the default timeout value for the amount of time this client waits for a response to be pushed on RespChan before it fails the Do() call.

const DefaultHTTPRequestTimeout = 1 * time.Second

Variables

ErrTestConstPicker is error returned by test const picker.

var ErrTestConstPicker = fmt.Errorf("const picker error")

func AwaitNoStateChange

func AwaitNoStateChange(ctx context.Context, t *testing.T, sc StateChanger, currState connectivity.State)

AwaitNoStateChange expects ctx to be canceled before sc's state leaves currState, and fatal errors otherwise.

func AwaitNotState

func AwaitNotState(ctx context.Context, t *testing.T, sc StateChanger, stateDoNotWant connectivity.State)

AwaitNotState waits for sc to leave stateDoNotWant or fatal errors if it doesn't happen before ctx expires.

func AwaitState

func AwaitState(ctx context.Context, t *testing.T, sc StateChanger, stateWant connectivity.State)

AwaitState waits for sc to enter stateWant or fatal errors if it doesn't happen before ctx expires.

func IsRoundRobin

func IsRoundRobin(want []balancer.SubConn, f func() balancer.SubConn) error

IsRoundRobin checks whether f's return value is roundrobin of elements from want. But it doesn't check for the order. Note that want can contain duplicate items, which makes it weight-round-robin.

Step 1. the return values of f should form a permutation of all elements in want, but not necessary in the same order. E.g. if want is {a,a,b}, the check fails if f returns:

If error is found in this step, the returned error contains only the first iteration until where it goes wrong.

Step 2. the return values of f should be repetitions of the same permutation. E.g. if want is {a,a,b}, the check failes if f returns:

If error is found in this step, the returned error contains the first iteration + the second iteration until where it goes wrong.

func LocalTCPListener

func LocalTCPListener() (net.Listener, error)

LocalTCPListener returns a net.Listener listening on local address and port.

func MarshalAny

func MarshalAny(t *testing.T, m proto.Message) *anypb.Any

MarshalAny is a convenience function to marshal protobuf messages into any protos. function will fail the test with a fatal error if the marshaling fails.

func MustParseURL

func MustParseURL(target string) *url.URL

MustParseURL attempts to parse the provided target using url.Parse() and panics if parsing fails.

func NewTestWRR

func NewTestWRR() wrr.WRR

NewTestWRR return a WRR for testing. It's deterministic instead of random.

func ParsePort

func ParsePort(t *testing.T, addr string) uint32

ParsePort returns the port from the given address string, as a unit32.

func StatusErrEqual

func StatusErrEqual(err1, err2 error) bool

StatusErrEqual returns true iff both err1 and err2 wrap status.Status errors and their underlying status protos are equal.

func StayConnected

func StayConnected(ctx context.Context, sc StateChanger)

StayConnected makes sc stay connected by repeatedly calling sc.Connect() until the state becomes Shutdown or until ithe context expires.

func SubConnFromPicker

func SubConnFromPicker(p balancer.Picker) func() balancer.SubConn

SubConnFromPicker returns a function which returns a SubConn by calling the Pick() method of the provided picker. There is no caching of SubConns here. Every invocation of the returned function results in a new pick.

type BalancerClientConn

BalancerClientConn is a mock balancer.ClientConn used in tests.

type BalancerClientConn struct {
    NewSubConnAddrsCh      chan []resolver.Address // the last 10 []Address to create subconn.
    NewSubConnCh           chan *TestSubConn       // the last 10 subconn created.
    ShutdownSubConnCh      chan *TestSubConn       // the last 10 subconn removed.
    UpdateAddressesAddrsCh chan []resolver.Address // last updated address via UpdateAddresses().

    NewPickerCh  chan balancer.Picker            // the last picker updated.
    NewStateCh   chan connectivity.State         // the last state.
    ResolveNowCh chan resolver.ResolveNowOptions // the last ResolveNow().
    // contains filtered or unexported fields
}

func NewBalancerClientConn

func NewBalancerClientConn(t *testing.T) *BalancerClientConn

NewBalancerClientConn creates a BalancerClientConn.

func (*BalancerClientConn) NewSubConn

func (tcc *BalancerClientConn) NewSubConn(a []resolver.Address, o balancer.NewSubConnOptions) (balancer.SubConn, error)

NewSubConn creates a new SubConn.

func (*BalancerClientConn) RemoveSubConn

func (tcc *BalancerClientConn) RemoveSubConn(sc balancer.SubConn)

RemoveSubConn is a nop; tests should all be updated to use sc.Shutdown() instead.

func (*BalancerClientConn) ResolveNow

func (tcc *BalancerClientConn) ResolveNow(o resolver.ResolveNowOptions)

ResolveNow panics.

func (*BalancerClientConn) Target

func (tcc *BalancerClientConn) Target() string

Target panics.

func (*BalancerClientConn) UpdateAddresses

func (tcc *BalancerClientConn) UpdateAddresses(sc balancer.SubConn, addrs []resolver.Address)

UpdateAddresses updates the addresses on the SubConn.

func (*BalancerClientConn) UpdateState

func (tcc *BalancerClientConn) UpdateState(bs balancer.State)

UpdateState updates connectivity state and picker.

func (*BalancerClientConn) WaitForConnectivityState

func (tcc *BalancerClientConn) WaitForConnectivityState(ctx context.Context, want connectivity.State) error

WaitForConnectivityState waits until the state pushed to this ClientConn matches the wanted state. Returns an error if the provided context expires, including the last received state (if any).

func (*BalancerClientConn) WaitForErrPicker

func (tcc *BalancerClientConn) WaitForErrPicker(ctx context.Context) error

WaitForErrPicker waits until an error picker is pushed to this ClientConn. Returns error if the provided context expires or a non-error picker is pushed to the ClientConn.

func (*BalancerClientConn) WaitForPicker

func (tcc *BalancerClientConn) WaitForPicker(ctx context.Context, f func(balancer.Picker) error) error

WaitForPicker waits for a picker that results in f returning nil. If the context expires, returns the last error returned by f (if any).

func (*BalancerClientConn) WaitForPickerWithErr

func (tcc *BalancerClientConn) WaitForPickerWithErr(ctx context.Context, want error) error

WaitForPickerWithErr waits until an error picker is pushed to this ClientConn with the error matching the wanted error. Returns an error if the provided context expires, including the last received picker error (if any).

func (*BalancerClientConn) WaitForRoundRobinPicker

func (tcc *BalancerClientConn) WaitForRoundRobinPicker(ctx context.Context, want ...balancer.SubConn) error

WaitForRoundRobinPicker waits for a picker that passes IsRoundRobin. Also drains the matching state channel and requires it to be READY (if an entry is pending) to be considered. Returns an error if the provided context expires, including the last received error from IsRoundRobin or the picker (if any).

type Channel

Channel wraps a generic channel and provides a timed receive operation.

type Channel struct {
    // C is the underlying channel on which values sent using the SendXxx() methods are delivered.
    // Tests which cannot use ReceiveXxx() for whatever reasons can use C to read the values.
    C chan any
}

func NewChannel

func NewChannel() *Channel

NewChannel returns a new Channel.

func NewChannelWithSize

func NewChannelWithSize(bufSize int) *Channel

NewChannelWithSize returns a new Channel with a buffer of bufSize.

func (*Channel) Receive

func (c *Channel) Receive(ctx context.Context) (any, error)

Receive returns the value received on the underlying channel, or the error returned by ctx if it is closed or cancelled.

func (*Channel) ReceiveOrFail

func (c *Channel) ReceiveOrFail() (any, bool)

ReceiveOrFail returns the value on the underlying channel and true, or nil and false if the channel was empty.

func (*Channel) Replace

func (c *Channel) Replace(value any)

Replace clears the value on the underlying channel, and sends the new value.

It's expected to be used with a size-1 channel, to only keep the most up-to-date item. This method is inherently racy when invoked concurrently from multiple goroutines.

func (*Channel) Send

func (c *Channel) Send(value any)

Send sends value on the underlying channel.

func (*Channel) SendContext

func (c *Channel) SendContext(ctx context.Context, value any) error

SendContext sends value on the underlying channel, or returns an error if the context expires.

func (*Channel) SendOrFail

func (c *Channel) SendOrFail(value any) bool

SendOrFail attempts to send value on the underlying channel. Returns true if successful or false if the channel was full.

type ConnWrapper

ConnWrapper wraps a net.Conn and pushes on a channel when closed.

type ConnWrapper struct {
    net.Conn
    CloseCh *Channel
}

func (*ConnWrapper) Close

func (cw *ConnWrapper) Close() error

Close closes the connection and sends a value on the close channel.

type FakeHTTPClient

FakeHTTPClient helps mock out HTTP calls made by the code under test. It makes HTTP requests made by the code under test available through a channel, and makes it possible to inject various responses.

type FakeHTTPClient struct {
    // ReqChan exposes the HTTP.Request made by the code under test.
    ReqChan *Channel
    // RespChan is a channel on which this fake client accepts responses to be
    // sent to the code under test.
    RespChan *Channel
    // Err, if set, is returned by Do().
    Err error
    // RecvTimeout is the amount of the time this client waits for a response to
    // be pushed on RespChan before it fails the Do() call. If this field is
    // left unspecified, DefaultHTTPRequestTimeout is used.
    RecvTimeout time.Duration
}

func (*FakeHTTPClient) Do

func (fc *FakeHTTPClient) Do(req *http.Request) (*http.Response, error)

Do pushes req on ReqChan and returns the response available on RespChan.

type ListenerWrapper

ListenerWrapper wraps a net.Listener and the returned net.Conn.

It pushes on a channel whenever it accepts a new connection.

type ListenerWrapper struct {
    net.Listener
    NewConnCh *Channel
}

func NewListenerWrapper

func NewListenerWrapper(t *testing.T, lis net.Listener) *ListenerWrapper

NewListenerWrapper returns a ListenerWrapper.

func (*ListenerWrapper) Accept

func (l *ListenerWrapper) Accept() (net.Conn, error)

Accept wraps the Listener Accept and sends the accepted connection on a channel.

type Logger

Logger wraps the logging methods from testing.T.

type Logger interface {
    Log(args ...any)
    Logf(format string, args ...any)
    Errorf(format string, args ...any)
}

type PipeListener

PipeListener is a listener with an unbuffered pipe. Each write will complete only once the other side reads. It should only be created using NewPipeListener.

type PipeListener struct {
    // contains filtered or unexported fields
}

func NewPipeListener

func NewPipeListener() *PipeListener

NewPipeListener creates a new pipe listener.

func (*PipeListener) Accept

func (p *PipeListener) Accept() (net.Conn, error)

Accept accepts a connection.

func (*PipeListener) Addr

func (p *PipeListener) Addr() net.Addr

Addr returns a pipe addr.

func (*PipeListener) Close

func (p *PipeListener) Close() error

Close closes the listener.

func (*PipeListener) Dialer

func (p *PipeListener) Dialer() func(string, time.Duration) (net.Conn, error)

Dialer dials a connection.

type ResolverClientConn

ResolverClientConn is a fake implementation of the resolver.ClientConn interface to be used in tests.

type ResolverClientConn struct {
    resolver.ClientConn // Embedding the interface to avoid implementing deprecated methods.

    Logger       Logger                     // Tests should pass testing.T for this.
    UpdateStateF func(resolver.State) error // Invoked when resolver pushes a state update.
    ReportErrorF func(err error)            // Invoked when resolver pushes an error.
}

func (*ResolverClientConn) ParseServiceConfig

func (t *ResolverClientConn) ParseServiceConfig(jsonSC string) *serviceconfig.ParseResult

ParseServiceConfig parses the provided service by delegating the work to the implementation in the grpc package.

func (*ResolverClientConn) ReportError

func (t *ResolverClientConn) ReportError(err error)

ReportError pushes the error received from the resolver on to ErrorCh.

func (*ResolverClientConn) UpdateState

func (t *ResolverClientConn) UpdateState(s resolver.State) error

UpdateState invokes the test specified callback with the update received from the resolver. If the callback returns a non-nil error, the same will be propagated to the resolver.

type RestartableListener

RestartableListener wraps a net.Listener and supports stopping and restarting the latter.

type RestartableListener struct {
    // contains filtered or unexported fields
}

func NewRestartableListener

func NewRestartableListener(l net.Listener) *RestartableListener

NewRestartableListener returns a new RestartableListener wrapping l.

func (*RestartableListener) Accept

func (l *RestartableListener) Accept() (net.Conn, error)

Accept waits for and returns the next connection to the listener.

If the listener is currently not accepting new connections, because `Stop` was called on it, the connection is immediately closed after accepting without any bytes being sent on it.

func (*RestartableListener) Addr

func (l *RestartableListener) Addr() net.Addr

Addr returns the listener's network address.

func (*RestartableListener) Close

func (l *RestartableListener) Close() error

Close closes the listener.

func (*RestartableListener) Restart

func (l *RestartableListener) Restart()

Restart gets a previously stopped listener to start accepting connections.

func (*RestartableListener) Stop

func (l *RestartableListener) Stop()

Stop closes existing connections on the listener and prevents new connections from being accepted.

type StateChanger

A StateChanger reports state changes, e.g. a grpc.ClientConn.

type StateChanger interface {
    // Connect begins connecting the StateChanger.
    Connect()
    // GetState returns the current state of the StateChanger.
    GetState() connectivity.State
    // WaitForStateChange returns true when the state becomes s, or returns
    // false if ctx is canceled first.
    WaitForStateChange(ctx context.Context, s connectivity.State) bool
}

type StubStatsHandler

StubStatsHandler is a stats handler that is easy to customize within individual test cases. It is a stubbable implementation of google.golang.org/grpc/stats.Handler for testing purposes.

type StubStatsHandler struct {
    TagRPCF     func(ctx context.Context, info *stats.RPCTagInfo) context.Context
    HandleRPCF  func(ctx context.Context, info stats.RPCStats)
    TagConnF    func(ctx context.Context, info *stats.ConnTagInfo) context.Context
    HandleConnF func(ctx context.Context, info stats.ConnStats)
}

func (*StubStatsHandler) HandleConn

func (ssh *StubStatsHandler) HandleConn(ctx context.Context, cs stats.ConnStats)

HandleConn calls the StubStatsHandler's HandleConnF, if set.

func (*StubStatsHandler) HandleRPC

func (ssh *StubStatsHandler) HandleRPC(ctx context.Context, rs stats.RPCStats)

HandleRPC calls the StubStatsHandler's HandleRPCF, if set.

func (*StubStatsHandler) TagConn

func (ssh *StubStatsHandler) TagConn(ctx context.Context, info *stats.ConnTagInfo) context.Context

TagConn calls the StubStatsHandler's TagConnF, if set.

func (*StubStatsHandler) TagRPC

func (ssh *StubStatsHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context

TagRPC calls the StubStatsHandler's TagRPCF, if set.

type TestConstPicker

TestConstPicker is a const picker for tests.

type TestConstPicker struct {
    Err error
    SC  balancer.SubConn
}

func (*TestConstPicker) Pick

func (tcp *TestConstPicker) Pick(info balancer.PickInfo) (balancer.PickResult, error)

Pick returns the const SubConn or the error.

type TestSubConn

TestSubConn implements the SubConn interface, to be used in tests.

type TestSubConn struct {
    ConnectCh chan struct{}
    // contains filtered or unexported fields
}

func NewTestSubConn

func NewTestSubConn(id string) *TestSubConn

NewTestSubConn returns a newly initialized SubConn. Typically, subconns should be created via TestClientConn.NewSubConn instead, but can be useful for some tests.

func (*TestSubConn) Connect

func (tsc *TestSubConn) Connect()

Connect is a no-op.

func (*TestSubConn) GetOrBuildProducer

func (tsc *TestSubConn) GetOrBuildProducer(balancer.ProducerBuilder) (balancer.Producer, func())

GetOrBuildProducer is a no-op.

func (*TestSubConn) Shutdown

func (tsc *TestSubConn) Shutdown()

Shutdown pushes the SubConn to the ShutdownSubConn channel in the parent TestClientConn.

func (*TestSubConn) String

func (tsc *TestSubConn) String() string

String implements stringer to print human friendly error message.

func (*TestSubConn) UpdateAddresses

func (tsc *TestSubConn) UpdateAddresses([]resolver.Address)

UpdateAddresses is a no-op.

func (*TestSubConn) UpdateState

func (tsc *TestSubConn) UpdateState(state balancer.SubConnState)

UpdateState pushes the state to the listener, if one is registered.

Subdirectories

Name Synopsis
..