Documentation

Overview

    Package yarpctest provides utilities to test YARPC services and clients.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func ChooserNop

    func ChooserNop(nop string) func(*FakePeerChooser)

      ChooserNop is a fake option for NewFakePeerChooser that sets a nop var. It's fake.

      func ContextWithCall

      func ContextWithCall(ctx context.Context, call *Call) context.Context

        ContextWithCall builds a Context which will yield the provided request metadata when used with yarpc.CallFromContext.

        ctx := yarpctest.ContextWithCall(ctx, &Call{..})
        handler.GetValue(ctx, &Request{...})
        

        func FakePeerChooserPreset

        func FakePeerChooserPreset() yarpcconfig.PeerChooserPreset

          FakePeerChooserPreset is a PeerChooserPreset which builds a FakePeerList buind to a FakePeerListUpdater.

          func FakePeerChooserSpec

          func FakePeerChooserSpec() yarpcconfig.PeerChooserSpec

            FakePeerChooserSpec returns a configurator spec for the fake-chooser FakePeerChooser peer selection strategy, suitable for passing to Configurator.MustRegisterPeerChooser.

            func FakePeerListSpec

            func FakePeerListSpec() yarpcconfig.PeerListSpec

              FakePeerListSpec returns a configurator spec for the fake-list FakePeerList peer selection strategy, suitable for passing to Configurator.MustRegisterPeerList.

              func FakePeerListUpdaterSpec

              func FakePeerListUpdaterSpec() yarpcconfig.PeerListUpdaterSpec

                FakePeerListUpdaterSpec returns a configurator spec for the fake-updater FakePeerListUpdater type, suitable for passing to Configurator.MustRegisterPeerListUpdaterSpec.

                func FakeTransportSpec

                func FakeTransportSpec() yarpcconfig.TransportSpec

                  FakeTransportSpec returns a configurator spec for the fake-transport transport type, suitable for passing to Configurator.MustRegisterTransport.

                  func ListNop

                  func ListNop(nop string) func(*FakePeerList)

                    ListNop is a fake option for NewFakePeerList that sets a nop var. It's fake.

                    func NewFakeConfigurator

                    func NewFakeConfigurator(opts ...yarpcconfig.Option) *yarpcconfig.Configurator

                      NewFakeConfigurator returns a configurator with fake-transport, fake-peer-list, and fake-peer-list-updater specs already registered, suitable for testing the configurator.

                      func UpdaterNop

                      func UpdaterNop(nop string) func(*FakePeerListUpdater)

                        UpdaterNop is a fake option for NewFakePeerListUpdater that sets a nop var. It's fake.

                        func Watch

                        func Watch(u *FakePeerListUpdater)

                          Watch is a fake option for NewFakePeerListUpdater that enables "watch". It's fake.

                          Types

                          type Call

                          type Call struct {
                          	Caller          string
                          	Service         string
                          	Transport       string
                          	Procedure       string
                          	Encoding        transport.Encoding
                          	Headers         map[string]string
                          	ShardKey        string
                          	RoutingKey      string
                          	RoutingDelegate string
                          	CallerProcedure string
                          
                          	// If set, this map will be filled with response headers written to
                          	// yarpc.Call.
                          	ResponseHeaders map[string]string
                          }

                            Call specifies metadata for ContextWithCall.

                            type FakeOutbound

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

                              FakeOutbound is a unary outbound for the FakeTransport. It is fake.

                              func (*FakeOutbound) Call

                                Call mimicks sending a oneway RPC.

                                By default, this returns a error. The OutboundCallOverride option supplies an alternate implementation. Alternately, the OutboundRouter option may allow this function to route a unary request to a unary handler.

                                func (*FakeOutbound) CallOneway

                                func (o *FakeOutbound) CallOneway(ctx context.Context, req *transport.Request) (transport.Ack, error)

                                  CallOneway mimicks sending a oneway RPC.

                                  By default, this returns an error. The OutboundCallOnewayOverride supplies an alternate implementation. Atlernately, the OutboundRouter options may route the request through to a oneway handler.

                                  func (*FakeOutbound) CallStream

                                  func (o *FakeOutbound) CallStream(ctx context.Context, streamReq *transport.StreamRequest) (*transport.ClientStream, error)

                                    CallStream mimicks sending a streaming RPC.

                                    By default, this returns an error. The OutboundCallStreamOverride option provides a hook to change the behavior. Alternately, the OutboundRouter option may route the request through to a streaming handler.

                                    func (*FakeOutbound) Chooser

                                    func (o *FakeOutbound) Chooser() peer.Chooser

                                      Chooser returns theis FakeOutbound's peer chooser.

                                      func (*FakeOutbound) IsRunning

                                      func (o *FakeOutbound) IsRunning() bool

                                        IsRunning returns whether the fake outbound is running.

                                        func (*FakeOutbound) NopOption

                                        func (o *FakeOutbound) NopOption() string

                                          NopOption returns this FakeOutbound's nopOption. It is fake.

                                          func (*FakeOutbound) Start

                                          func (o *FakeOutbound) Start() error

                                            Start starts the fake outbound and its chooser.

                                            func (*FakeOutbound) Stop

                                            func (o *FakeOutbound) Stop() error

                                              Stop stops the fake outbound and its chooser.

                                              func (*FakeOutbound) TransportName

                                              func (o *FakeOutbound) TransportName() string

                                                TransportName is "fake".

                                                func (*FakeOutbound) Transports

                                                func (o *FakeOutbound) Transports() []transport.Transport

                                                  Transports returns the FakeTransport that owns this outbound.

                                                  type FakeOutboundConfig

                                                  type FakeOutboundConfig struct {
                                                  	yarpcconfig.PeerChooser
                                                  
                                                  	Nop string `config:"nop,interpolate"`
                                                  }

                                                    FakeOutboundConfig configures the FakeOutbound.

                                                    type FakeOutboundOption

                                                    type FakeOutboundOption func(*FakeOutbound)

                                                      FakeOutboundOption is an option for FakeTransport.NewOutbound.

                                                      func NopOutboundOption

                                                      func NopOutboundOption(nopOption string) FakeOutboundOption

                                                        NopOutboundOption returns an option to set the "nopOption" for a FakeTransport.NewOutbound. The nopOption has no effect exists only to verify that the option was passed, via `FakeOutbound.NopOption()`.

                                                        func OutboundCallOnewayOverride

                                                        func OutboundCallOnewayOverride(callable OutboundOnewayCallable) FakeOutboundOption

                                                          OutboundCallOnewayOverride returns an option to set the "callOverride" for a FakeTransport.NewOutbound.

                                                          This can be used to set the functionality for the FakeOutbound's `CallOneway` function.

                                                          func OutboundCallOverride

                                                          func OutboundCallOverride(callable OutboundCallable) FakeOutboundOption

                                                            OutboundCallOverride returns an option to set the "callOverride" for a FakeTransport.NewOutbound. This can be used to set the functionality for the FakeOutbound's `Call` function.

                                                            func OutboundCallStreamOverride

                                                            func OutboundCallStreamOverride(callable OutboundStreamCallable) FakeOutboundOption

                                                              OutboundCallStreamOverride returns an option to set the "callOverride" for a FakeTransport.NewOutbound.

                                                              This can be used to set the functionality for the FakeOutbound's `CallStream` function.

                                                              func OutboundName

                                                              func OutboundName(name string) FakeOutboundOption

                                                                OutboundName sets the name of the "fake" outbound.

                                                                func OutboundRouter

                                                                func OutboundRouter(router transport.Router) FakeOutboundOption

                                                                  OutboundRouter returns an option to set the router for outbound requests. This connects the outbound to the inbound side of a handler for testing purposes.

                                                                  type FakePeer

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

                                                                    FakePeer is a fake peer with an identifier.

                                                                    func (*FakePeer) EndRequest

                                                                    func (p *FakePeer) EndRequest()

                                                                      EndRequest decrements pending request count.

                                                                      func (*FakePeer) Identifier

                                                                      func (p *FakePeer) Identifier() string

                                                                        Identifier returns the fake peer identifier.

                                                                        func (*FakePeer) StartRequest

                                                                        func (p *FakePeer) StartRequest()

                                                                          StartRequest increments pending request count.

                                                                          func (*FakePeer) Status

                                                                          func (p *FakePeer) Status() peer.Status

                                                                            Status returns the fake peer status.

                                                                            func (*FakePeer) String

                                                                            func (p *FakePeer) String() string

                                                                              String returns a humane representation of the peer and its status for debugging.

                                                                              type FakePeerChooser

                                                                              type FakePeerChooser struct {
                                                                              	transport.Lifecycle
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                FakePeerChooser is a fake peer chooser.

                                                                                func NewFakePeerChooser

                                                                                func NewFakePeerChooser(opts ...FakePeerChooserOption) *FakePeerChooser

                                                                                  NewFakePeerChooser returns a fake peer list.

                                                                                  func (*FakePeerChooser) Choose

                                                                                  func (c *FakePeerChooser) Choose(ctx context.Context, req *transport.Request) (peer.Peer, func(error), error)

                                                                                    Choose pretends to choose a peer, but actually always returns an error. It's fake.

                                                                                    func (*FakePeerChooser) Nop

                                                                                    func (c *FakePeerChooser) Nop() string

                                                                                      Nop returns the Peer Chooser's nop variable.

                                                                                      type FakePeerChooserConfig

                                                                                      type FakePeerChooserConfig struct {
                                                                                      	Nop string `config:"nop,interpolate"`
                                                                                      }

                                                                                        FakePeerChooserConfig configures the FakePeerChooser.

                                                                                        type FakePeerChooserOption

                                                                                        type FakePeerChooserOption func(*FakePeerChooser)

                                                                                          FakePeerChooserOption is an option for NewFakePeerChooser.

                                                                                          type FakePeerList

                                                                                          type FakePeerList struct {
                                                                                          	transport.Lifecycle
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                            FakePeerList is a fake peer list.

                                                                                            func NewFakePeerList

                                                                                            func NewFakePeerList(opts ...FakePeerListOption) *FakePeerList

                                                                                              NewFakePeerList returns a fake peer list.

                                                                                              func (*FakePeerList) Choose

                                                                                              func (c *FakePeerList) Choose(ctx context.Context, req *transport.Request) (peer.Peer, func(error), error)

                                                                                                Choose pretends to choose a peer, but actually always returns an error. It's fake.

                                                                                                func (*FakePeerList) Nop

                                                                                                func (c *FakePeerList) Nop() string

                                                                                                  Nop returns the Peer List's nop variable.

                                                                                                  func (*FakePeerList) Update

                                                                                                  func (c *FakePeerList) Update(up peer.ListUpdates) error

                                                                                                    Update pretends to add or remove peers.

                                                                                                    type FakePeerListConfig

                                                                                                    type FakePeerListConfig struct {
                                                                                                    	Nop string `config:"nop,interpolate"`
                                                                                                    }

                                                                                                      FakePeerListConfig configures the FakePeerList.

                                                                                                      type FakePeerListOption

                                                                                                      type FakePeerListOption func(*FakePeerList)

                                                                                                        FakePeerListOption is an option for NewFakePeerList.

                                                                                                        type FakePeerListUpdater

                                                                                                        type FakePeerListUpdater struct {
                                                                                                        	transport.Lifecycle
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          FakePeerListUpdater is a fake peer list updater. It doesn't actually update a peer list.

                                                                                                          func NewFakePeerListUpdater

                                                                                                          func NewFakePeerListUpdater(opts ...FakePeerListUpdaterOption) *FakePeerListUpdater

                                                                                                            NewFakePeerListUpdater returns a new FakePeerListUpdater, applying any passed options.

                                                                                                            func (*FakePeerListUpdater) Nop

                                                                                                            func (u *FakePeerListUpdater) Nop() string

                                                                                                              Nop returns the nop variable.

                                                                                                              func (*FakePeerListUpdater) Watch

                                                                                                              func (u *FakePeerListUpdater) Watch() bool

                                                                                                                Watch returns whether the peer list updater was configured to "watch". It is fake.

                                                                                                                type FakePeerListUpdaterConfig

                                                                                                                type FakePeerListUpdaterConfig struct {
                                                                                                                	FakeUpdater string `config:"fake-updater"`
                                                                                                                	Nop         string `config:"nop,interpolate"`
                                                                                                                	Watch       bool   `config:"watch"`
                                                                                                                }

                                                                                                                  FakePeerListUpdaterConfig configures a fake-updater FakePeerListUpdater. It has a fake "watch" property that adds the Watch option for NewFakePeerListUpdater when you build a peer list with this config.

                                                                                                                  type FakePeerListUpdaterOption

                                                                                                                  type FakePeerListUpdaterOption func(*FakePeerListUpdater)

                                                                                                                    FakePeerListUpdaterOption is an option for NewFakePeerListUpdater.

                                                                                                                    type FakeTransport

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

                                                                                                                      FakeTransport is a fake transport.

                                                                                                                      func NewFakeTransport

                                                                                                                      func NewFakeTransport(opts ...FakeTransportOption) *FakeTransport

                                                                                                                        NewFakeTransport returns a fake transport.

                                                                                                                        func (*FakeTransport) Flush

                                                                                                                        func (t *FakeTransport) Flush()

                                                                                                                          Flush effects all queued status changes from retaining or releasing peers.

                                                                                                                          Calling RetainPeer and ReleasePeer schedules a peer status change and its notifications. Concrete dialer implementations dispatch these notifications from a goroutine and subscribers may obtain a lock on the peer status. For testability, the fake transport queues these changes and calling Flush dispatches the notifications synchronously, but still off the RetainPeer and ReleasePeer stacks.

                                                                                                                          func (*FakeTransport) IsRunning

                                                                                                                          func (t *FakeTransport) IsRunning() bool

                                                                                                                            IsRunning returns whether the fake transport is running.

                                                                                                                            func (*FakeTransport) NewOutbound

                                                                                                                            func (t *FakeTransport) NewOutbound(c peer.Chooser, opts ...FakeOutboundOption) *FakeOutbound

                                                                                                                              NewOutbound returns a FakeOutbound with a given peer chooser and options.

                                                                                                                              func (*FakeTransport) NopOption

                                                                                                                              func (t *FakeTransport) NopOption() string

                                                                                                                                NopOption returns the configured nopOption. It's fake.

                                                                                                                                func (*FakeTransport) Peer

                                                                                                                                func (t *FakeTransport) Peer(id peer.Identifier) *FakePeer

                                                                                                                                  Peer returns the persistent peer object for that peer identifier for the lifetime of the fake transport.

                                                                                                                                  func (*FakeTransport) ReleasePeer

                                                                                                                                  func (t *FakeTransport) ReleasePeer(id peer.Identifier, ps peer.Subscriber) error

                                                                                                                                    ReleasePeer does nothing.

                                                                                                                                    func (*FakeTransport) RetainPeer

                                                                                                                                    func (t *FakeTransport) RetainPeer(id peer.Identifier, ps peer.Subscriber) (peer.Peer, error)

                                                                                                                                      RetainPeer returns a fake peer.

                                                                                                                                      func (*FakeTransport) SimulateConnect

                                                                                                                                      func (t *FakeTransport) SimulateConnect(id peer.Identifier)

                                                                                                                                        SimulateConnect simulates a connection to the peer, marking the peer as available and notifying subscribers.

                                                                                                                                        func (*FakeTransport) SimulateDisconnect

                                                                                                                                        func (t *FakeTransport) SimulateDisconnect(id peer.Identifier)

                                                                                                                                          SimulateDisconnect simulates a disconnection to the peer, marking the peer as unavailable and notifying subscribers.

                                                                                                                                          func (*FakeTransport) SimulateReleaseError

                                                                                                                                          func (t *FakeTransport) SimulateReleaseError(id peer.Identifier, err error)

                                                                                                                                            SimulateReleaseError leaves a note that any subsequent Release for a particular address should return an error.

                                                                                                                                            func (*FakeTransport) SimulateRetainError

                                                                                                                                            func (t *FakeTransport) SimulateRetainError(id peer.Identifier, err error)

                                                                                                                                              SimulateRetainError leaves a note that any subsequent Retain for a particular address should return an error.

                                                                                                                                              func (*FakeTransport) SimulateStatusChange

                                                                                                                                              func (t *FakeTransport) SimulateStatusChange(id peer.Identifier, status peer.ConnectionStatus)

                                                                                                                                                SimulateStatusChange simulates a connection or disconnection to the peer, marking the peer connection status and notifying all subscribers.

                                                                                                                                                func (*FakeTransport) Start

                                                                                                                                                func (t *FakeTransport) Start() error

                                                                                                                                                  Start spins up a goroutine to asynchronously flush status change notifications.

                                                                                                                                                  If you do not start a fake dialer, you must call Flush explicitly.

                                                                                                                                                  func (*FakeTransport) Stop

                                                                                                                                                  func (t *FakeTransport) Stop() error

                                                                                                                                                    Stop shuts down the fake dialer, allowing its status change notification loop to exit.

                                                                                                                                                    type FakeTransportConfig

                                                                                                                                                    type FakeTransportConfig struct {
                                                                                                                                                    	Nop string `config:"nop,interpolate"`
                                                                                                                                                    }

                                                                                                                                                      FakeTransportConfig configures the FakeTransport.

                                                                                                                                                      type FakeTransportOption

                                                                                                                                                      type FakeTransportOption func(*FakeTransport)

                                                                                                                                                        FakeTransportOption is an option for NewFakeTransport.

                                                                                                                                                        func InitialConnectionStatus

                                                                                                                                                        func InitialConnectionStatus(s peer.ConnectionStatus) FakeTransportOption

                                                                                                                                                          InitialConnectionStatus specifies the initial connection status for new peers of this transport. This is Available by default. With the status set to Unavailable, the test may manual simmulate connection and disconnection with the SimulateConnect and SimulateDisconnect methods.

                                                                                                                                                          func NopTransportOption

                                                                                                                                                          func NopTransportOption(nopOption string) FakeTransportOption

                                                                                                                                                            NopTransportOption returns a no-op option for NewFakeTransport. The option exists to verify that options work.

                                                                                                                                                            func ReleaseErrors

                                                                                                                                                            func ReleaseErrors(err error, addrs []string) FakeTransportOption

                                                                                                                                                              ReleaseErrors specifies an error for ReleasePeer to return for the given addresses.

                                                                                                                                                              func RetainErrors

                                                                                                                                                              func RetainErrors(err error, addrs []string) FakeTransportOption

                                                                                                                                                                RetainErrors specifies an error for RetainPeer to return for the given addresses.

                                                                                                                                                                type ListStressTest

                                                                                                                                                                type ListStressTest struct {
                                                                                                                                                                	Workers  int
                                                                                                                                                                	Duration time.Duration
                                                                                                                                                                	Timeout  time.Duration
                                                                                                                                                                	// Latency is the minimum latency of an individual call.
                                                                                                                                                                	// Higher latencies drive up concurrency per worker.
                                                                                                                                                                	Latency time.Duration
                                                                                                                                                                	// LowStress disables membership and connection churn, measuring peer
                                                                                                                                                                	// selection baseline performance without interference.
                                                                                                                                                                	LowStress bool
                                                                                                                                                                	New       func(peer.Transport) peer.ChooserList
                                                                                                                                                                }

                                                                                                                                                                  ListStressTest describes the parameters of a stress test for a peer list implementation.

                                                                                                                                                                  func (ListStressTest) Log

                                                                                                                                                                  func (t ListStressTest) Log(logger Logger)

                                                                                                                                                                    Log writes the parameters for a stress test.

                                                                                                                                                                    func (ListStressTest) Run

                                                                                                                                                                      Run runs a stress test on a peer list.

                                                                                                                                                                      The stress test creates a fake transport and a vector of fake peers. The test concurrently chooses peers from the list with some number of workers while simultaneously adding and removing peers from the peer list and simulating connection and disconnection with those peers.

                                                                                                                                                                      type ListStressTestReport

                                                                                                                                                                      type ListStressTestReport struct {
                                                                                                                                                                      	Workers int
                                                                                                                                                                      	Errors  int
                                                                                                                                                                      	Choices int
                                                                                                                                                                      	Updates int
                                                                                                                                                                      	Min     time.Duration
                                                                                                                                                                      	Max     time.Duration
                                                                                                                                                                      	Total   time.Duration
                                                                                                                                                                      }

                                                                                                                                                                        ListStressTestReport catalogs the results of a peer list stress test.

                                                                                                                                                                        Each worker keeps track of its own statistics then sends them through a channel to the test runner. This allows each worker to have independent memory for its log reports and reduces the need for synchronization across threads, which could interfere with the test. The reports get merged into a final report.

                                                                                                                                                                        func (*ListStressTestReport) Log

                                                                                                                                                                        func (r *ListStressTestReport) Log(logger Logger)

                                                                                                                                                                          Log writes the vital statistics for a stress test.

                                                                                                                                                                          type Logger

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

                                                                                                                                                                            Logger is the interface needed by reports to log results. The testing.T is an example of a logger.

                                                                                                                                                                            type OutboundCallable

                                                                                                                                                                            type OutboundCallable func(ctx context.Context, req *transport.Request) (*transport.Response, error)

                                                                                                                                                                              OutboundCallable is a function that will be called for for an outbound's `Call` method.

                                                                                                                                                                              type OutboundOnewayCallable

                                                                                                                                                                              type OutboundOnewayCallable func(context.Context, *transport.Request) (transport.Ack, error)

                                                                                                                                                                                OutboundOnewayCallable is a function that will be called for for an outbound's `Call` method.

                                                                                                                                                                                type OutboundStreamCallable

                                                                                                                                                                                type OutboundStreamCallable func(context.Context, *transport.StreamRequest) (*transport.ClientStream, error)

                                                                                                                                                                                  OutboundStreamCallable is a function that will be called for for an outbound's `Call` method.

                                                                                                                                                                                  Directories

                                                                                                                                                                                  Path Synopsis
                                                                                                                                                                                  Package recorder records & replay yarpc requests on the client side.
                                                                                                                                                                                  Package recorder records & replay yarpc requests on the client side.