Documentation

Overview

    Package testutil provides test utility functions.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	ApplyTimeout   = time.Second
    	RequestTimeout = 3 * time.Second
    )

    Functions

    func AfterTest

    func AfterTest(t *testing.T)

      AfterTest is meant to run in a defer that executes after a test completes. It will detect common goroutine leaks, retrying in case there are goroutines not synchronously torn down, and fail the test if any goroutines are stuck.

      func AssertEqual

      func AssertEqual(t *testing.T, e, a interface{}, msg ...string)

      func AssertFalse

      func AssertFalse(t *testing.T, v bool, msg ...string)

      func AssertNil

      func AssertNil(t *testing.T, v interface{})

      func AssertNotNil

      func AssertNotNil(t *testing.T, v interface{})

      func AssertTrue

      func AssertTrue(t *testing.T, v bool, msg ...string)

      func CheckAfterTest

      func CheckAfterTest(d time.Duration) error

        CheckAfterTest returns an error if AfterTest would fail with an error.

        func CheckLeakedGoroutine

        func CheckLeakedGoroutine() bool

          CheckLeakedGoroutine verifies tests do not leave any leaky goroutines. It returns true when there are goroutines still running(leaking) after all tests.

          import "github.com/coreos/etcd/pkg/testutil"
          
          func TestMain(m *testing.M) {
          	v := m.Run()
          	if v == 0 && testutil.CheckLeakedGoroutine() {
          		os.Exit(1)
          	}
          	os.Exit(v)
          }
          
          func TestSample(t *testing.T) {
          	defer testutil.AfterTest(t)
          	...
          }
          

          func FatalStack

          func FatalStack(t *testing.T, s string)

            FatalStack helps to fatal the test and print out the stacks of all running goroutines.

            func MustNewURL

            func MustNewURL(t *testing.T, s string) *url.URL

            func MustNewURLs

            func MustNewURLs(t *testing.T, urls []string) []url.URL

            func Poll

            func Poll(interval time.Duration, timeout time.Duration, condition ConditionFunc) (bool, error)

              Poll calls a condition function repeatedly on a polling interval until it returns true, returns an error or the timeout is reached. If the condition function returns true or an error before the timeout, Poll immediately returns with the true value or the error. If the timeout is exceeded, Poll returns false.

              func WaitSchedule

              func WaitSchedule()

                WaitSchedule briefly sleeps in order to invoke the go scheduler. TODO: improve this when we are able to know the schedule or status of target go-routine.

                Types

                type Action

                type Action struct {
                	Name   string
                	Params []interface{}
                }

                type ConditionFunc

                type ConditionFunc func() (bool, error)

                  ConditionFunc returns true when a condition is met.

                  type PauseableHandler

                  type PauseableHandler struct {
                  	Next http.Handler
                  	// contains filtered or unexported fields
                  }

                  func (*PauseableHandler) Pause

                  func (ph *PauseableHandler) Pause()

                  func (*PauseableHandler) Resume

                  func (ph *PauseableHandler) Resume()

                  func (*PauseableHandler) ServeHTTP

                  func (ph *PauseableHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

                  type Recorder

                  type Recorder interface {
                  	// Record publishes an Action (e.g., function call) which will
                  	// be reflected by Wait() or Chan()
                  	Record(a Action)
                  	// Wait waits until at least n Actions are available or returns with error
                  	Wait(n int) ([]Action, error)
                  	// Action returns immediately available Actions
                  	Action() []Action
                  	// Chan returns the channel for actions published by Record
                  	Chan() <-chan Action
                  }

                  func NewRecorderStream

                  func NewRecorderStream() Recorder

                  type RecorderBuffered

                  type RecorderBuffered struct {
                  	sync.Mutex
                  	// contains filtered or unexported fields
                  }

                    RecorderBuffered appends all Actions to a slice

                    func (*RecorderBuffered) Action

                    func (r *RecorderBuffered) Action() []Action

                    func (*RecorderBuffered) Chan

                    func (r *RecorderBuffered) Chan() <-chan Action

                    func (*RecorderBuffered) Record

                    func (r *RecorderBuffered) Record(a Action)

                    func (*RecorderBuffered) Wait

                    func (r *RecorderBuffered) Wait(n int) (acts []Action, err error)