assert

Nov 2, 2020

Changes in this version

type Assertion

+ var Nothing Assertion = nothingAssertion{}

+ type Operation int

+ const AdvanceTimeOperation

+ const CallOperation

+ const ExecuteCommandOperation

+ const RecordEventOperation

type S

+ Operation Operation

Jun 12, 2020

Changes in this version

+ type S struct

+ Facts []fact.Fact

+ func (s *S) Cleanup(fn func())

+ func (s *S) Error(args ...interface{})

+ func (s *S) Errorf(format string, args ...interface{})

+ func (s *S) Fail()

+ func (s *S) FailNow()

+ func (s *S) Failed() bool

+ func (s *S) Fatal(args ...interface{})

+ func (s *S) Fatalf(format string, args ...interface{})

+ func (s *S) Helper()

+ func (s *S) Log(args ...interface{})

+ func (s *S) Logf(format string, args ...interface{})

+ func (s *S) Name() string

+ func (s *S) Parallel()

+ func (s *S) Skip(args ...interface{})

+ func (s *S) SkipNow()

+ func (s *S) Skipf(format string, args ...interface{})

+ func (s *S) Skipped() bool

Jun 11, 2020

Changes in this version

type Assertion

+ Begin func(c compare.Comparator)

+ End func()

+ type T struct

+ Facts []fact.Fact

+ 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

Feb 4, 2020

Changes in this version

type Assertion

+ func Should(cr string, fn func(AssertionContext) error) Assertion

+ type AssertionContext struct

+ Comparator compare.Comparator

+ Facts []fact.Fact

Aug 1, 2019

Changes in this version

+ type Assertion interface

+ BuildReport func(ok bool, r render.Renderer) *Report

+ Ok func() bool

+ Prepare func(c compare.Comparator)

+ 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

+ type CompositeAssertion struct

+ Criteria string

+ Predicate func(int) (string, bool)

+ SubAssertions []Assertion

+ func (a *CompositeAssertion) BuildReport(ok bool, r render.Renderer) *Report

+ func (a *CompositeAssertion) Notify(f fact.Fact)

+ func (a *CompositeAssertion) Ok() bool

+ func (a *CompositeAssertion) Prepare(c compare.Comparator)

+ type MessageAssertion struct

+ func (a *MessageAssertion) BuildReport(ok bool, r render.Renderer) *Report

+ func (a *MessageAssertion) Notify(f fact.Fact)

+ func (a *MessageAssertion) Ok() bool

+ func (a *MessageAssertion) Prepare(c compare.Comparator)

+ type MessageTypeAssertion struct

+ func (a *MessageTypeAssertion) BuildReport(ok bool, r render.Renderer) *Report

+ func (a *MessageTypeAssertion) Notify(f fact.Fact)

+ func (a *MessageTypeAssertion) Ok() bool

+ func (a *MessageTypeAssertion) Prepare(c compare.Comparator)

+ type Report struct

+ Criteria string

+ Explanation string

+ Ok bool

+ Outcome string

+ Sections []*ReportSection

+ SubReports []*Report

+ TreeOk bool

+ func (r *Report) Append(sr *Report)

+ func (r *Report) Section(title string) *ReportSection

+ func (r *Report) WriteTo(next io.Writer) (_ int64, err error)

+ type ReportSection struct

+ Content strings.Builder

+ Title string

+ func (s *ReportSection) Append(f string, v ...interface{})

+ func (s *ReportSection) AppendListItem(f string, v ...interface{})