Documentation
¶
Overview ¶
Package assert contains the assertions used by the test runner.
Index ¶
- type Assertion
- func AllOf(subs ...Assertion) Assertion
- func AnyOf(subs ...Assertion) Assertion
- func CommandExecuted(m dogma.Message) Assertion
- func CommandTypeExecuted(m dogma.Message) Assertion
- func EventRecorded(m dogma.Message) Assertion
- func EventTypeRecorded(m dogma.Message) Assertion
- func NoneOf(subs ...Assertion) Assertion
- func Should(cr string, fn func(t *T)) Assertion
- type Report
- type ReportSection
- type T
- func (t *T) Cleanup(fn func())
- func (t *T) Error(args ...interface{})
- func (t *T) Errorf(format string, args ...interface{})
- func (t *T) Fail()
- func (t *T) FailNow()
- func (t *T) Failed() bool
- func (t *T) Fatal(args ...interface{})
- func (t *T) Fatalf(format string, args ...interface{})
- func (t *T) Helper()
- func (t *T) Log(args ...interface{})
- func (t *T) Logf(format string, args ...interface{})
- func (t *T) Name() string
- func (t *T) Parallel()
- func (t *T) Skip(args ...interface{})
- func (t *T) SkipNow()
- func (t *T) Skipf(format string, args ...interface{})
- func (t *T) Skipped() bool
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Assertion ¶
type Assertion interface {
fact.Observer
// Begin is called to prepare the assertion for a new test.
//
// c is the comparator used to compare messages and other entities.
Begin(c compare.Comparator)
// End is called once the test is complete.
End()
// Ok returns true if the assertion passed.
Ok() bool
// BuildReport generates a report about the assertion.
//
// ok is true if the assertion is considered to have passed. This may not be
// the same value as returned from Ok() when this assertion is used as a
// sub-assertion inside a composite.
BuildReport(ok, verbose bool, r render.Renderer) *Report
}
Assertion is a predicate that checks if some specific critiria was met during the execution of a test.
func AnyOf ¶
AnyOf returns an assertion that passes if at least one of the given sub-assertions passes.
func CommandExecuted ¶
CommandExecuted returns an assertion that passes if m is executed as a command.
func CommandTypeExecuted ¶
CommandTypeExecuted returns an assertion that passes if a message with the same type as m is executed as a command.
func EventRecorded ¶
EventRecorded returns an assertion that passes if m is recorded as an event.
func EventTypeRecorded ¶
EventTypeRecorded returns an assertion that passes if a message with the same type as m is recorded as an event.
func Should ¶ added in v0.4.0
Should returns an assertion that uses a user-defined function to check for specific criteria.
cr is a human-readable description of the "criteria" or the "expectation" that results in a passing assertion. It should be phrased as an imperative statement, such as "insert a customer".
fn is the function that performs the assertion logic. It is passed a *T value, which is a superset of the *testing.T struct that is passed
type Report ¶
type Report struct {
// TreeOk is true if the "tree" that the assertion belongs to passed.
TreeOk bool
// Ok is true if this assertion passed.
Ok bool
// Criteria is a brief description of the assertion's requirement to pass.
Criteria string
// Outcome is a brief description of the outcome of the assertion.
Outcome string
// Explanation is a brief description of what actually happened during the
// test as it relates to this assertion.
Explanation string
// Sections contains arbitrary "sections" that are added to the report by
// the assertion.
Sections []*ReportSection
// SubReports contains the reports of any sub-assertions.
SubReports []*Report
}
Report is a report on the outcome of an assertion.
func (*Report) Section ¶
func (r *Report) Section(title string) *ReportSection
Section adds an arbitrary "section" to the report.
type ReportSection ¶
ReportSection is a section of a report containing additional information about the assertion.
func (*ReportSection) Append ¶
func (s *ReportSection) Append(f string, v ...interface{})
Append appends a line of text to the section's content.
func (*ReportSection) AppendListItem ¶
func (s *ReportSection) AppendListItem(f string, v ...interface{})
AppendListItem appends a line of text prefixed with a bullet.
type T ¶ added in v0.5.0
type T struct {
// Comparator provides logic for comparing messages and application state.
compare.Comparator
// Facts is an ordered slice of the facts that occurred.
Facts []fact.Fact
// contains filtered or unexported fields
}
T is a superset of *testing.T that is passed to user-defined assertion functions.
func (*T) Cleanup ¶ added in v0.5.0
func (t *T) Cleanup(fn func())
Cleanup registers a function to be called when the test is complete. Cleanup functions will be called in last added, first called order.
func (*T) Error ¶ added in v0.5.0
func (t *T) Error(args ...interface{})
Error is equivalent to Log() followed by Fail().
func (*T) Fail ¶ added in v0.5.0
func (t *T) Fail()
Fail marks the function as having failed but continues execution.
func (*T) FailNow ¶ added in v0.5.0
func (t *T) FailNow()
FailNow marks the function as having failed and stops its execution.
func (*T) Fatal ¶ added in v0.5.0
func (t *T) Fatal(args ...interface{})
Fatal is equivalent to Log() followed by FailNow().
func (*T) Helper ¶ added in v0.5.0
func (t *T) Helper()
Helper marks the calling function as a test helper function.
It is a no-op in this implementation, but is included to increase compatibility with the *testing.T type.
func (*T) Log ¶ added in v0.5.0
func (t *T) Log(args ...interface{})
Log formats its arguments using default formatting, analogous to Println(), and records the text in the assertion report.
func (*T) Logf ¶ added in v0.5.0
Logf formats its arguments according to the format, analogous to Printf(), and records the text in the assertion report.
func (*T) Parallel ¶ added in v0.5.0
func (t *T) Parallel()
Parallel signals that this test is to be run in parallel with (and only with) other parallel tests.
It is a no-op in this implementation, but is included to increase compatibility with the *testing.T type.
func (*T) Skip ¶ added in v0.5.0
func (t *T) Skip(args ...interface{})
Skip is equivalent to Log() followed by SkipNow().
func (*T) SkipNow ¶ added in v0.5.0
func (t *T) SkipNow()
SkipNow marks the test as having been skipped and stops its execution.
Source Files