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 A
• type AssertFunc
  • func New(t T) AssertFunc
• type HttpResponse
  • func (t *HttpResponse) StatusCode(exp int, m, p string, opt ...interface{})
• type T

Examples

• HttpResponse.StatusCode
• New

Types

type A

type A interface {
	T
	Equals(got, exp interface{}) T
	Contains(body, exp interface{}) T
	ResponseFrom(http.Handler) *HttpResponse
}

type AssertFunc

type AssertFunc func(expr ...bool) A

func New

func New(t T) AssertFunc

Assert returns an asserter 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 HttpResponse

type HttpResponse struct {
	T
	http.Handler
}

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 T

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