gregoryv/asserter

package asserter

import (
    "bytes"
    "io"
    "io/ioutil"
    "net/http"
    "reflect"
    "strconv"
    "strings"

    "github.com/sergi/go-diff/diffmatchpatch"
)

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

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

// Testar combines testing.T with and Asserter
type Testar interface {
    T
    Asserter
}

func Wrap(t T) *WrappedT {
    return &WrappedT{t}
}

// New returns a WrappedT.Assert func for online assertions.
func New(t T) AssertFunc {
    return Wrap(t).Assert
}

type AssertFunc func(expr ...bool) Testar

type WrappedT struct {
    T
}

func (w *WrappedT) Assert(expr ...bool) Testar {
    if len(expr) > 1 {
        w.T.Helper()
        w.T.Fatal("Only 0 or 1 bool expressions are allowed")
    }
    if len(expr) == 0 || !expr[0] {
        return w
    }
    return &noopT{}
}

func (w *WrappedT) Helper() {
    /* Cannot use the asserter as helper */
}

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

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

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

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

func (w *WrappedT) Fail() {
    w.T.Helper()
    w.T.Fail()
}

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

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

// Helpers

// Equals fails with error if got is different from exp.
// Returns T for e.g. logging extra or calling Fatal if needed.
func (w *WrappedT) Equals(got, exp interface{}) T {
    w.T.Helper()
    if !reflect.DeepEqual(got, exp) {
        got := string(toBytes(w.T, got, "got"))
        exp := string(toBytes(w.T, exp, "exp"))

        if strings.Contains(got, "\n") || strings.Contains(exp, "\n") {
            w.Errorf("\n%s", diff(string(got), string(exp)))
            return w.T
        }
        w.Errorf("\ngot: %v\nexp: %v", got, exp)
    }
    return w.T
}

func (w *WrappedT) NotEqual(a, b interface{}) T {
    w.T.Helper()

    A := string(toBytes(w.T, a, "a"))
    B := string(toBytes(w.T, b, "b"))

    if A == B {
        w.Error("a and b are equal")
        return w.T
    }
    return &noopT{}
}

func diff(got, exp string) string {
    dmp := diffmatchpatch.New()
    diffs := dmp.DiffMain(exp, got, false)
    return dmp.DiffPrettyText(diffs)
}

// Contains checks the body for the given expression.
// The body can be various types.
func (w *WrappedT) Contains(body, exp interface{}) T {
    w.T.Helper()
    b := toBytes(w.T, body, "body")
    e := toBytes(w.T, exp, "exp")

    if bytes.Index(b, e) == -1 {
        format := "%q does not contain %q"
        if bytes.Index(b, []byte("\n")) > -1 {
            format = "%s\ndoes not contain\n%s"
        }
        w.Errorf(format, string(b), string(e))
    }
    return w.T
}

// ----------------------------------------

type AssertErrFunc func(error) T

func NewErrors(t T) (ok, bad AssertErrFunc) {
    t.Helper()
    return Wrap(t).Errors()
}

func (w *WrappedT) Errors() (ok, bad AssertErrFunc) {
    w.T.Helper()
    return w.Ok, w.Bad
}

func (w *WrappedT) Ok(err error) T {
    w.T.Helper()
    if err != nil {
        w.T.Error(err)
        return w
    }
    return &noopT{}
}

func (w *WrappedT) Bad(err error) T {
    w.T.Helper()
    if err == nil {
        w.T.Error("expected error")
        return w
    }
    return &noopT{}
}

// ------------

func NewFatalErrors(t T) (ok, bad AssertErrFunc) {
    t.Helper()
    return Wrap(t).FatalErrors()
}

func (w *WrappedT) FatalErrors() (ok, bad AssertErrFunc) {
    w.T.Helper()
    return w.MustOk, w.MustBad
}

func (w *WrappedT) MustOk(err error) T {
    w.T.Helper()
    if err != nil {
        w.T.Fatal(err)
        return w
    }
    return &noopT{}
}

func (w *WrappedT) MustBad(err error) T {
    w.T.Helper()
    if err == nil {
        w.T.Fatal("expected error")
        return w
    }
    return &noopT{}
}

// ----------------------------------------

type MixedErrFunc func(interface{}, error) T

func NewMixed(t T) (ok, bad MixedErrFunc) {
    t.Helper()
    return Wrap(t).Mixed()
}

func (w *WrappedT) Mixed() (ok, bad MixedErrFunc) {
    w.T.Helper()
    return w.MixOk, w.MixBad
}

func (w *WrappedT) MixOk(any interface{}, err error) T {
    w.T.Helper()
    if err != nil {
        w.T.Error(err)
        return w
    }
    return &noopT{}
}

func (w *WrappedT) MixBad(any interface{}, err error) T {
    w.T.Helper()
    if err == nil {
        w.T.Error("expected error")
        return w
    }
    return &noopT{}
}

// ---------

func NewFatalMixed(t T) (ok, bad MixedErrFunc) {
    t.Helper()
    return Wrap(t).FatalMixed()
}

func (w *WrappedT) FatalMixed() (ok, bad MixedErrFunc) {
    w.T.Helper()
    return w.MustMixOk, w.MustMixBad
}

func (w *WrappedT) MustMixOk(any interface{}, err error) T {
    w.T.Helper()
    if err != nil {
        w.T.Fatal(err)
        return w
    }
    return &noopT{}
}

func (w *WrappedT) MustMixBad(any interface{}, err error) T {
    w.T.Helper()
    if err == nil {
        w.T.Fatal("should fail")
        return w
    }
    return &noopT{}
}

// ----------------------------------------

func (w *WrappedT) ResponseFrom(h http.Handler) *HttpResponse {
    return &HttpResponse{w.T, h}
}

func toBytes(t T, v interface{}, name string) (b []byte) {
    switch v := v.(type) {
    case []byte:
        return v
    case string:
        return []byte(v)
    case int:
        return []byte(strconv.Itoa(v))
    case io.Reader:
        return bytesOrError(v)
    }
    t.Fatalf("%s must be io.Reader, []byte, string or int", name)
    return
}

func bytesOrError(r io.Reader) []byte {
    body, err := ioutil.ReadAll(r)
    if err != nil {
        return []byte(err.Error())
    }
    return body
}

type noopT struct{}

func (t *noopT) Assert(...bool) Testar            { return t }
func (t *noopT) Helper()                          {}
func (t *noopT) Error(...interface{})             {}
func (t *noopT) Errorf(string, ...interface{})    {}
func (t *noopT) Fatal(...interface{})             {}
func (t *noopT) Fatalf(string, ...interface{})    {}
func (t *noopT) Fail()                            {}
func (t *noopT) FailNow()                         {}
func (t *noopT) Log(...interface{})               {}
func (t *noopT) Logf(string, ...interface{})      {}
func (t *noopT) Equals(got, exp interface{}) T    { return t }
func (t *noopT) NotEqual(a, b interface{}) T      { return t }
func (t *noopT) Contains(body, exp interface{}) T { return t }
func (t *noopT) ResponseFrom(h http.Handler) *HttpResponse {
    return &HttpResponse{t, h}
}
func (t *noopT) Errors() (ok, bad AssertErrFunc) {
    return func(error) T { return t },
        func(error) T { return t }
}

func (t *noopT) Mixed() (ok, bad MixedErrFunc) {
    return func(interface{}, error) T { return t },
        func(interface{}, error) T { return t }
}