async

Asynchronous assertions: Eventually & Consistently

Expect asserts now. When the thing under test settles over time, poll it. See gomega:overview for the mental model and gomega:assertions for the synchronous side. Dot-import assumed; with plain testing use g := NewWithT(t) and call g.Eventually(...). Docs: https://onsi.github.io/gomega/#making-asynchronous-assertions.

• Eventually — polls until the matcher passes or the timeout elapses. Default: poll every 10ms for up to 1s.
• Consistently — polls for the whole duration and fails if the matcher ever fails. Default: poll every 10ms for 100ms. Use it to assert something "does not eventually" happen.

Eventually(client.FetchCount).Should(BeNumerically(">=", 17))
Consistently(channel).ShouldNot(Receive())   // nothing ever arrives

The three things you can poll

1. A bare value — rarely what you want. Gomega passes the value to the matcher every poll, but nothing re-reads it.

Eventually(c, "50ms").Should(BeClosed())   // works: matcher re-inspects the channel

This is only correct for values whose matcher re-inspects live state (channels, *gexec.Session, *gbytes.Buffer). Gotcha: Eventually(s).Should(Equal("changed")) or Eventually(slice).Should(HaveLen(3)) will not see updates — the value is captured once, and racing a goroutine over it trips the race detector. Pass a function instead.

2. A function returning at least one value. Polled repeatedly; the first return value goes to the matcher.

Eventually(func() int { return client.FetchCount() }).Should(BeNumerically(">=", 17))

The multi-return error idiom applies: extra return values must all be zero, so a (value, error) function fails the poll while err != nil and matches value once it's nil.

func FetchFromDB() (string, error)
Eventually(FetchFromDB).Should(Equal("got it"))   // passes when err==nil AND string matches

Pass arguments with .WithArguments(...) (supports variadic):