package clockwork

import "github.com/jonboulle/clockwork"

Index ¶

• func AddToContext(ctx context.Context, clock Clock) context.Context
• type Clock
• func FromContext(ctx context.Context) Clock
• func NewRealClock() Clock
• type FakeClock
• func NewFakeClock() FakeClock
• func NewFakeClockAt(t time.Time) FakeClock
• type Ticker
• type Timer

Functions ¶

func AddToContext ¶

func AddToContext(ctx context.Context, clock Clock) context.Context

AddToContext creates a derived context that references the specified clock.

Types ¶

type Clock ¶

type Clock interface {
	After(d time.Duration) <-chan time.Time
	Sleep(d time.Duration)
	Now() time.Time
	Since(t time.Time) time.Duration
	NewTicker(d time.Duration) Ticker
	NewTimer(d time.Duration) Timer
	AfterFunc(d time.Duration, f func()) Timer
}

Clock provides an interface that packages can use instead of directly using the time module, so that chronology-related behavior can be tested.

func FromContext ¶

func FromContext(ctx context.Context) Clock

FromContext extracts a clock from the context. If not present, a real clock is returned.

func NewRealClock ¶

func NewRealClock() Clock

NewRealClock returns a Clock which simply delegates calls to the actual time package; it should be used by packages in production.

type FakeClock ¶

type FakeClock interface {
	Clock
	// Advance advances the FakeClock to a new point in time, ensuring any existing
	// waiters are notified appropriately before returning.
	Advance(d time.Duration)
	// BlockUntil blocks until the FakeClock has the given number of waiters.
	BlockUntil(waiters int)
}

FakeClock provides an interface for a clock which can be manually advanced through time.

FakeClock maintains a list of "waiters," which consists of all callers waiting on the underlying clock (i.e. Tickers and Timers including callers of Sleep or After). Users can call BlockUntil to block until the clock has an expected number of waiters.

func NewFakeClock ¶

func NewFakeClock() FakeClock

NewFakeClock returns a FakeClock implementation which can be manually advanced through time for testing. The initial time of the FakeClock will be the current system time.

Tests that require a deterministic time must use NewFakeClockAt.

func NewFakeClockAt ¶

func NewFakeClockAt(t time.Time) FakeClock

NewFakeClockAt returns a FakeClock initialised at the given time.Time.

type Ticker ¶

type Ticker interface {
	Chan() <-chan time.Time
	Reset(d time.Duration)
	Stop()
}

Ticker provides an interface which can be used instead of directly using time.Ticker. The real-time ticker t provides ticks through t.C which becomes t.Chan() to make this channel requirement definable in this interface.

type Timer ¶

type Timer interface {
	Chan() <-chan time.Time
	Reset(d time.Duration) bool
	Stop() bool
}

Timer provides an interface which can be used instead of directly using time.Timer. The real-time timer t provides events through t.C which becomes t.Chan() to make this channel requirement definable in this interface.

Source Files ¶

clockwork.go context.go ticker.go timer.go