testlib

type MockClock ¶

type MockClock interface {
	clock.Clock
	SetNow(time.Time)

	// GetNextFireTime returns the time that the next Timer will fire, or the zero value if no timers
	// are set.
	GetNextFireTime() time.Time
}

MockClock is an extension of Clock that adds the ability to set the current time. Now returns the value passed to SetNow until a new value is set.

Timers created by a MockClock will fire once the clock's time is set to or after the calculated fire time. This helps enable deterministic tests involving timers. However, because a MockClock's time doesn't continuously increase, a couple of considerations should be followed to avoid racy conditions in tests.

1. Avoid calls to Clock.Now() outside of the test thread. For example, when creating timers asynchronously, avoid calls to clock.Now() and instead get the base time from the test thread. e.g.,

   func NewComponent(c clock.Clock) *Component { c = &Component{clock: c} go c.run(c.Now()) // Retrieve the initial time from this thread. }

   func (c *Component) run(now time.Time) { fireAt := now.Add(someDelay) for { tmr := c.clock.NewTimerAt(fireAt) select { case <-c.someChan: c.handleEvent()

   case n := <-tmr.GetC(): c.somePeriodicOperation() // Compute next fire time based on value received from timer. fireAt = n.Add(someDelay) } tmr.Cancel() }

2. When creating a new timer, use Clock.NewTimerAt(time.Time) to specify a point in time at which the timer should fire, and calculate that time based on a known base time (#1). Using Clock.NewTimer(time.Duration) can lead to race conditions in tests:

   d := someDelay - c.clock.Now().Sub(c.lastFireTime) // <-- if the MockClock's time is advanced here, the new timer may not fire when expected. tmr := c.clock.NewTimer(d)

   Instead:

   now := c.clock.Now() nextFire := now.Add(someDelay - now.Sub(c.lastFireTime)) tmr := c.clock.NewTimerAt(nextFire)

func NewMockClock() MockClock

type MockEndpoint ¶

type MockEndpoint struct {
	Used     bool
	Released bool
	// contains filtered or unexported fields
}

Type MockEndpoint is a mock endpoint.Endpoint.

func NewMockEndpoint(name string) *MockEndpoint

func (ep *MockEndpoint) BuildReport(report metrics.StampedMetricReport) (pipeline.EndpointReport, error)

func (wfc *MockEndpoint) Calls() int32

func (wfc *MockEndpoint) DoAndWait(t *testing.T, calls int32, f func())

func (ep *MockEndpoint) IsTransient(err error) bool

func (ep *MockEndpoint) Name() string

func (ep *MockEndpoint) Release() error

func (ep *MockEndpoint) Reports() (reports []pipeline.EndpointReport)

func (ep *MockEndpoint) Send(report pipeline.EndpointReport) error

func (ep *MockEndpoint) SetBuildErr(err error)

func (ep *MockEndpoint) SetSendErr(err error)

func (ep *MockEndpoint) Use()

type MockInput ¶

type MockInput struct {
	Used     bool
	Released bool
	// contains filtered or unexported fields
}

Type MockInput is a mock pipeline.Input.

func NewMockInput() *MockInput

func (i *MockInput) AddReport(report metrics.MetricReport) error

func (wfc *MockInput) Calls() int32

func (wfc *MockInput) DoAndWait(t *testing.T, calls int32, f func())

func (i *MockInput) Release() error

func (i *MockInput) Reports() (reports []metrics.MetricReport)

func (i *MockInput) SetAddError(err error)

func (i *MockInput) Use()

type MockSender ¶

type MockSender struct {
	Used     bool
	Released bool
	// contains filtered or unexported fields
}

Type MockSender is a mock sender.Sender.

func NewMockSender(endpoints ...string) *MockSender

func (wfc *MockSender) Calls() int32

func (wfc *MockSender) DoAndWait(t *testing.T, calls int32, f func())

func (s *MockSender) Endpoints() []string

func (s *MockSender) Release() error

func (s *MockSender) Reports() (reports []metrics.MetricReport)

func (s *MockSender) Send(report metrics.StampedMetricReport) error

func (s *MockSender) SetSendError(err error)

func (s *MockSender) Use()

type MockStatsRecorder ¶

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

Type MockStatsRecorder is a mock stats.StatsRecorder.

func NewMockStatsRecorder() *MockStatsRecorder

func (wfc *MockStatsRecorder) Calls() int32

func (wfc *MockStatsRecorder) DoAndWait(t *testing.T, calls int32, f func())

func (sr *MockStatsRecorder) Failed() []RecordedEntry

func (sr *MockStatsRecorder) Register(id string, handlers []string)

func (sr *MockStatsRecorder) Registered() map[string][]string

func (sr *MockStatsRecorder) SendFailed(id string, handler string)

func (sr *MockStatsRecorder) SendSucceeded(id string, handler string)

func (sr *MockStatsRecorder) Succeeded() []RecordedEntry

type RecordedEntry ¶

type RecordedEntry struct {
	Id      string
	Handler string
}