peertest

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 11, 2017 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ApplyPeerListActions 

func ApplyPeerListActions(t *testing.T, pl peer.Chooser, actions []PeerListAction, deps ListActionDeps)

ApplyPeerListActions runs all the PeerListActions on the PeerList

func ApplyTransportActions 

func ApplyTransportActions(t *testing.T, transport peer.Transport, actions []TransportAction, d TransportDeps)

ApplyTransportActions runs all the TransportActions on the peer Transport

func CreatePeerIDs 

func CreatePeerIDs(peerIDStrs []string) []peer.Identifier

CreatePeerIDs takes a slice of peerID strings and returns a slice of PeerIdentifiers

func CreateSubscriberMap 

func CreateSubscriberMap(
	mockCtrl *gomock.Controller,
	subDefinitions []SubscriberDefinition,
) map[string]peer.Subscriber

CreateSubscriberMap will take a slice of SubscriberDefinitions and return a map of IDs to MockPeerSubscribers

func ExpectPeerReleases 

func ExpectPeerReleases(
	transport *MockTransport,
	peerStrs []string,
	err error,
)

ExpectPeerReleases registers expectations on a MockTransport to release peers through the ReleasePeer function

func ExpectPeerRetains 

func ExpectPeerRetains(
	transport *MockTransport,
	availablePeerStrs []string,
	unavailablePeerStrs []string,
) map[string]*LightMockPeer

ExpectPeerRetains registers expectations on a MockTransport to generate peers on the RetainPeer function

func ExpectPeerRetainsWithError 

func ExpectPeerRetainsWithError(
	transport *MockTransport,
	peerStrs []string,
	err error,
)

ExpectPeerRetainsWithError registers expectations on a MockTransport return errors

Types

type ChooseAction 

type ChooseAction struct {
	InputContext        context.Context
	InputContextTimeout time.Duration
	InputRequest        *transport.Request
	ExpectedPeer        string
	ExpectedErr         error
}

ChooseAction is an action for choosing a peer from the peerlist

func (ChooseAction) Apply 

func (a ChooseAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply runs "Choose" on the peerList and validates the peer && error

type ChooseMultiAction 

type ChooseMultiAction struct {
	ExpectedPeers []string
}

ChooseMultiAction will run Choose multiple times on the PeerList It will assert if there are ANY failures

func (ChooseMultiAction) Apply 

func (a ChooseMultiAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply runs "Choose" on the peerList for every ExpectedPeer

type ConcurrentAction 

type ConcurrentAction struct {
	Actions []PeerListAction
	Wait    time.Duration
}

ConcurrentAction will run a series of actions in parallel

func (ConcurrentAction) Apply 

func (a ConcurrentAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply runs all the ConcurrentAction's actions in goroutines with a delay of `Wait` between each action. Returns when all actions have finished executing

type LightMockPeer 

type LightMockPeer struct {
	MockPeerIdentifier

	PeerStatus peer.Status
}

LightMockPeer is a small simple wrapper around the Peer interface for mocking and changing a peer's attributes MockPeer is NOT thread safe

func NewLightMockPeer 

func NewLightMockPeer(pid MockPeerIdentifier, conStatus peer.ConnectionStatus) *LightMockPeer

NewLightMockPeer returns a new MockPeer

func (*LightMockPeer) EndRequest 

func (p *LightMockPeer) EndRequest()

EndRequest should be run after a MockPeer request has finished

func (*LightMockPeer) StartRequest 

func (p *LightMockPeer) StartRequest()

StartRequest is run when a Request starts

func (*LightMockPeer) Status 

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

Status returns the Status Object of the MockPeer

type ListActionDeps 

type ListActionDeps struct {
	Peers map[string]*LightMockPeer
}

ListActionDeps are passed through PeerListActions' Apply methods in order to allow the PeerListAction to modify state other than just the PeerList

type MockChooser 

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

Mock of Chooser interface

func NewMockChooser 

func NewMockChooser(ctrl *gomock.Controller) *MockChooser

func (*MockChooser) Choose 

func (_m *MockChooser) Choose(_param0 context.Context, _param1 *transport.Request) (peer.Peer, func(error), error)

func (*MockChooser) EXPECT 

func (_m *MockChooser) EXPECT() *_MockChooserRecorder

func (*MockChooser) IsRunning 

func (_m *MockChooser) IsRunning() bool

func (*MockChooser) Start 

func (_m *MockChooser) Start() error

func (*MockChooser) Stop 

func (_m *MockChooser) Stop() error

type MockIdentifier 

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

Mock of Identifier interface

func NewMockIdentifier 

func NewMockIdentifier(ctrl *gomock.Controller) *MockIdentifier

func (*MockIdentifier) EXPECT 

func (_m *MockIdentifier) EXPECT() *_MockIdentifierRecorder

func (*MockIdentifier) Identifier 

func (_m *MockIdentifier) Identifier() string

type MockList 

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

Mock of List interface

func NewMockList 

func NewMockList(ctrl *gomock.Controller) *MockList

func (*MockList) EXPECT 

func (_m *MockList) EXPECT() *_MockListRecorder

func (*MockList) Update 

func (_m *MockList) Update(_param0 peer.ListUpdates) error

type MockPeer 

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

Mock of Peer interface

func NewMockPeer 

func NewMockPeer(ctrl *gomock.Controller) *MockPeer

func (*MockPeer) EXPECT 

func (_m *MockPeer) EXPECT() *_MockPeerRecorder

func (*MockPeer) EndRequest 

func (_m *MockPeer) EndRequest()

func (*MockPeer) Identifier 

func (_m *MockPeer) Identifier() string

func (*MockPeer) StartRequest 

func (_m *MockPeer) StartRequest()

func (*MockPeer) Status 

func (_m *MockPeer) Status() peer.Status

type MockPeerIdentifier 

type MockPeerIdentifier string

MockPeerIdentifier is a small wrapper around the PeerIdentifier interfaces for a string unfortunately gomock + assert.Equal has difficulty seeing between mock objects of the same type.

func (MockPeerIdentifier) Identifier 

func (pid MockPeerIdentifier) Identifier() string

Identifier returns a unique identifier for MockPeerIDs

type MockSubscriber 

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

Mock of Subscriber interface

func NewMockSubscriber 

func NewMockSubscriber(ctrl *gomock.Controller) *MockSubscriber

func (*MockSubscriber) EXPECT 

func (_m *MockSubscriber) EXPECT() *_MockSubscriberRecorder

func (*MockSubscriber) NotifyStatusChanged 

func (_m *MockSubscriber) NotifyStatusChanged(_param0 peer.Identifier)

type MockTransport 

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

Mock of Transport interface

func NewMockTransport 

func NewMockTransport(ctrl *gomock.Controller) *MockTransport

func (*MockTransport) EXPECT 

func (_m *MockTransport) EXPECT() *_MockTransportRecorder

func (*MockTransport) ReleasePeer 

func (_m *MockTransport) ReleasePeer(_param0 peer.Identifier, _param1 peer.Subscriber) error

func (*MockTransport) RetainPeer 

func (_m *MockTransport) RetainPeer(_param0 peer.Identifier, _param1 peer.Subscriber) (peer.Peer, error)

type NotifyStatusChangeAction 

type NotifyStatusChangeAction struct {
	// PeerID is a unique identifier to the Peer we want use in the notification
	PeerID string

	// NewConnectionStatus is the new ConnectionStatus of the Peer
	NewConnectionStatus peer.ConnectionStatus
}

NotifyStatusChangeAction will run the NotifyStatusChange function on a PeerList with a specified Peer after changing the peer's ConnectionStatus

func (NotifyStatusChangeAction) Apply 

func (a NotifyStatusChangeAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply will run the NotifyStatusChanged function on the PeerList with the provided Peer

type PeerIdentifierMatcher 

type PeerIdentifierMatcher string

PeerIdentifierMatcher is used to match a Peer/PeerIdentifier by comparing The peer's .Identifier function with the Matcher string

func (PeerIdentifierMatcher) Matches 

func (pim PeerIdentifierMatcher) Matches(got interface{}) bool

Matches returns true of got is equivalent to the PeerIdentifier Matching string

func (PeerIdentifierMatcher) String 

func (pim PeerIdentifierMatcher) String() string

String returns a description of the matcher

type PeerListAction 

type PeerListAction interface {
	// Apply runs a function on the PeerList and asserts the result
	Apply(*testing.T, peer.Chooser, ListActionDeps)
}

PeerListAction defines actions that can be applied to a PeerList

type ReleaseAction 

type ReleaseAction struct {
	InputIdentifierID string
	InputSubscriberID string
	ExpectedErrType   error
}

ReleaseAction will execute the ReleasePeer method on the Transport

func (ReleaseAction) Apply 

func (a ReleaseAction) Apply(t *testing.T, transport peer.Transport, deps TransportDeps)

Apply will execute the ReleasePeer method on the Transport

type RetainAction 

type RetainAction struct {
	InputIdentifierID string
	InputSubscriberID string
	ExpectedErr       error
	ExpectedPeerID    string
}

RetainAction will execute the RetainPeer method on the Transport

func (RetainAction) Apply 

func (a RetainAction) Apply(t *testing.T, transport peer.Transport, deps TransportDeps)

Apply will execute the RetainPeer method on the Transport

type StartAction 

type StartAction struct {
	ExpectedErr error
}

StartAction is an action for testing PeerList.Start

func (StartAction) Apply 

func (a StartAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply runs "Start" on the peerList and validates the error

type StopAction 

type StopAction struct {
	ExpectedErr error
}

StopAction is an action for testing PeerList.Stop

func (StopAction) Apply 

func (a StopAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply runs "Stop" on the peerList and validates the error

type SubscriberDefinition 

type SubscriberDefinition struct {
	ID                  string
	ExpectedNotifyCount int
}

SubscriberDefinition is an abstraction for defining a PeerSubscriber with an ID so it can be referenced later.

type TransportAction 

type TransportAction interface {
	// Apply runs a function on the Transport and asserts the result
	Apply(*testing.T, peer.Transport, TransportDeps)
}

TransportAction defines actions that can be applied to an Transport

type TransportDeps 

type TransportDeps struct {
	PeerIdentifiers map[string]peer.Identifier
	Subscribers     map[string]peer.Subscriber
}

TransportDeps are passed through all the TransportActions in order to pass certain state in between Actions

type UpdateAction 

type UpdateAction struct {
	AddedPeerIDs   []string
	RemovedPeerIDs []string
	ExpectedErr    error
}

UpdateAction is an action for adding/removing multiple peers on the PeerList

func (UpdateAction) Apply 

func (a UpdateAction) Apply(t *testing.T, pl peer.Chooser, deps ListActionDeps)

Apply runs "Update" on the peer.Chooser after casting it to a peer.List and validates the error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.