asserter

README

asserter - Package for oneline assertions

Quick start

go get github.com/gregoryv/asserter

In your tests

func Test_something(t *testing.T) {
    got, err := something()

    assert := asserter.New(t)
    assert(err == nil).Fatal(err)
    assert(got == exp).Errorf("%v, expected %v", got, exp)
    // same as
    assert().Equals(got, exp)

    assert().Contains(got, "text")
    assert().Contains(got, 1)

    // Check readers content
    resp, err := http.Get("http://example.com")
    assert(err == nil).Fatal(err)
    assert().Contains(resp.Body, "<title>")
}

Documentation

Overview

package defines AssertFunc wrapper of testing.T

Online assertions are done by wrapping the T in a test

func TestSomething(t *testing.T) {
    assert := asserter.New(t)
    got, err := Something()
    t.Logf("%v, %v := Something()", got, err)
    assert(err == nil).Fail()
    // Special case used very often is check equality
    assert().Equals(got, 1)
}

Index

• type AssertErrFunc
  • func NewErrors(t T) (ok, bad AssertErrFunc)
  • func NewFatalErrors(t T) (ok, bad AssertErrFunc)
• type AssertFunc
  • func New(t T) AssertFunc
• type Asserter
• type HttpResponse
  • func (t *HttpResponse) BodyEquals(exp []byte, m, p string, opt ...interface{})
  • func (t *HttpResponse) BodyIs(exp string, m, p string, opt ...interface{})
  • func (t *HttpResponse) Contains(exp string, m, p string, opt ...interface{})
  • func (t *HttpResponse) Header(k, exp string, m, p string, opt ...interface{})
  • func (t *HttpResponse) StatusCode(exp int, m, p string, opt ...interface{})
• type MixedErrFunc
  • func NewFatalMixed(t T) (ok, bad MixedErrFunc)
  • func NewMixed(t T) (ok, bad MixedErrFunc)
• type T
• type Testar
• type WrappedT
  • func Wrap(t T) *WrappedT
  • func (w *WrappedT) Assert(expr ...bool) Testar
  • func (w *WrappedT) Bad(err error) T
  • func (w *WrappedT) Contains(body, exp interface{}) T
  • func (w *WrappedT) Equals(got, exp interface{}) T
  • func (w *WrappedT) Error(args ...interface{})
  • func (w *WrappedT) Errorf(format string, args ...interface{})
  • func (w *WrappedT) Errors() (ok, bad AssertErrFunc)
  • func (w *WrappedT) Fail()
  • func (w *WrappedT) FailNow()
  • func (w *WrappedT) Fatal(args ...interface{})
  • func (w *WrappedT) FatalErrors() (ok, bad AssertErrFunc)
  • func (w *WrappedT) FatalMixed() (ok, bad MixedErrFunc)
  • func (w *WrappedT) Fatalf(format string, args ...interface{})
  • func (w *WrappedT) Helper()
  • func (w *WrappedT) Log(args ...interface{})
  • func (w *WrappedT) Logf(format string, args ...interface{})
  • func (w *WrappedT) MixBad(any interface{}, err error) T
  • func (w *WrappedT) MixOk(any interface{}, err error) T
  • func (w *WrappedT) Mixed() (ok, bad MixedErrFunc)
  • func (w *WrappedT) MustBad(err error) T
  • func (w *WrappedT) MustMixBad(any interface{}, err error) T
  • func (w *WrappedT) MustMixOk(any interface{}, err error) T
  • func (w *WrappedT) MustOk(err error) T
  • func (w *WrappedT) Ok(err error) T
  • func (w *WrappedT) ResponseFrom(h http.Handler) *HttpResponse

Examples

• HttpResponse.StatusCode
• New

Types

type AssertErrFunc

type AssertErrFunc func(error) T

func NewErrors

func NewErrors(t T) (ok, bad AssertErrFunc)

func NewFatalErrors

func NewFatalErrors(t T) (ok, bad AssertErrFunc)

type AssertFunc

type AssertFunc func(expr ...bool) Testar

func New

func New(t T) AssertFunc

New returns a WrappedT.Assert func for online assertions.

Example

package main

import (
	"net/http"
	"testing"

	"github.com/gregoryv/asserter"
)

var t = &testing.T{}

func main() {
	assert := asserter.New(t)
	assert(1 != 2).Errorf("...")
	got, exp := 1, 1
	assert(got == exp).Fail()
	assert().Equals(got, exp)
}

type Asserter

type Asserter interface {
	Assert(...bool) Testar
	Equals(got, exp interface{}) T
	Contains(body, exp interface{}) T
	ResponseFrom(http.Handler) *HttpResponse
	Errors() (ok, bad AssertErrFunc)
	Mixed() (ok, bad MixedErrFunc)
}

type HttpResponse

type HttpResponse struct {
	T
	http.Handler
}

func (*HttpResponse) BodyEquals

func (t *HttpResponse) BodyEquals(exp []byte, m, p string, opt ...interface{})

func (*HttpResponse) BodyIs

func (t *HttpResponse) BodyIs(exp string, m, p string, opt ...interface{})

BodyIs the same as BodyEquals

func (*HttpResponse) Contains

func (t *HttpResponse) Contains(exp string, m, p string, opt ...interface{})

Contains fails if body does not contain exp

func (*HttpResponse) Header

func (t *HttpResponse) Header(k, exp string, m, p string, opt ...interface{})

Header checks if the k header matches exp value

func (*HttpResponse) StatusCode

func (t *HttpResponse) StatusCode(exp int, m, p string, opt ...interface{})

StatusCode checks the expected status code. Options can be io.Reader for body, http.Header for headers or string for an error message.

Example

package main

import (
	"net/http"
	"strings"
	"testing"

	"github.com/gregoryv/asserter"
)

var (
	t       = &testing.T{}
	handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
)

func main() {
	assert := asserter.New(t)
	exp := assert().ResponseFrom(handler)
	exp.StatusCode(200, "POST", "/", strings.NewReader("the body"))
	exp.StatusCode(200, "GET", "/", "should be ok")
	exp.StatusCode(200, "GET", "/")
}

type MixedErrFunc

type MixedErrFunc func(interface{}, error) T

func NewFatalMixed

func NewFatalMixed(t T) (ok, bad MixedErrFunc)

func NewMixed

func NewMixed(t T) (ok, bad MixedErrFunc)

type T

type T interface {
	Helper()
	Error(...interface{})
	Errorf(string, ...interface{})
	Fatal(...interface{})
	Fatalf(string, ...interface{})
	Fail()
	FailNow()
	Log(...interface{})
	Logf(string, ...interface{})
}

type Testar

type Testar interface {
	T
	Asserter
}

Testar combines testing.T with and Asserter

type WrappedT

type WrappedT struct {
	T
}

func Wrap

func Wrap(t T) *WrappedT

func (*WrappedT) Assert

func (w *WrappedT) Assert(expr ...bool) Testar

func (*WrappedT) Bad

func (w *WrappedT) Bad(err error) T

func (*WrappedT) Contains

func (w *WrappedT) Contains(body, exp interface{}) T

Contains checks the body for the given expression. The body can be various types.

func (*WrappedT) Equals

func (w *WrappedT) Equals(got, exp interface{}) T

func (*WrappedT) Error

func (w *WrappedT) Error(args ...interface{})

func (*WrappedT) Errorf

func (w *WrappedT) Errorf(format string, args ...interface{})

func (*WrappedT) Errors

func (w *WrappedT) Errors() (ok, bad AssertErrFunc)

func (*WrappedT) Fail

func (w *WrappedT) Fail()

func (*WrappedT) FailNow

func (w *WrappedT) FailNow()

func (*WrappedT) Fatal

func (w *WrappedT) Fatal(args ...interface{})

func (*WrappedT) FatalErrors

func (w *WrappedT) FatalErrors() (ok, bad AssertErrFunc)

func (*WrappedT) FatalMixed

func (w *WrappedT) FatalMixed() (ok, bad MixedErrFunc)

func (*WrappedT) Fatalf

func (w *WrappedT) Fatalf(format string, args ...interface{})

func (*WrappedT) Helper

func (w *WrappedT) Helper()

func (*WrappedT) Log

func (w *WrappedT) Log(args ...interface{})

func (*WrappedT) Logf

func (w *WrappedT) Logf(format string, args ...interface{})

func (*WrappedT) MixBad

func (w *WrappedT) MixBad(any interface{}, err error) T

func (*WrappedT) MixOk

func (w *WrappedT) MixOk(any interface{}, err error) T

func (*WrappedT) Mixed

func (w *WrappedT) Mixed() (ok, bad MixedErrFunc)

func (*WrappedT) MustBad

func (w *WrappedT) MustBad(err error) T

func (*WrappedT) MustMixBad

func (w *WrappedT) MustMixBad(any interface{}, err error) T

func (*WrappedT) MustMixOk

func (w *WrappedT) MustMixOk(any interface{}, err error) T

func (*WrappedT) MustOk

func (w *WrappedT) MustOk(err error) T

func (*WrappedT) Ok

func (w *WrappedT) Ok(err error) T

func (*WrappedT) ResponseFrom

func (w *WrappedT) ResponseFrom(h http.Handler) *HttpResponse