assert

README

assert

Lightweight assertion library based on the fluent interface from assertj

Features

The matchers included in our assert library are fully compatible with, and depend on the standard Go testing package. These just add a little syntactic sugar on top of the familiar test patterns.

To use the example from the testing documentation, here is how one would normally write a test in Go:

func TestAbs(t *testing.T) {
    got := Abs(-1)
    if got != 1 {
        t.Errorf("Abs(-1) = %d; want 1", got)
    }
}

With the matchers included in our assert package, one would write:

import "github.com/metaleaf-io/assert"

func TestAbs(t *testing.T) {
    got := Abs(-1)
    assert.With(t).
        That(got).
        IsEqualTo(1)
}

This is much more readable and ultimately leads to more maintainable code.

Usage

The matchers currently included in the assert package are:

1. IsEmpty/IsNotEmpty

   func TestIsEmpty(t *testing.T) {
       s := ""
       assert.With(t).
           That(s).
           IsEmpty()
   }
   

   func TestIsNotEmpty(t *testing.T) {
       s := "foobar"
       assert.With(t).
           That(s).
           IsNotEmpty()
   }
   

2. IsEqualTo

   func TestEquals(t *testing.T) {
       got := Abs(-1)
       assert.With(t).
           That(got).
           IsEqualTo(1)
   }
   

3. IsGreaterThan

   func TestIsEmpty(t *testing.T) {
       x := 1
       assert.With(t).
           That(x).
           IsGreaterThan(0)
   }
   

4. IsNil/IsNotNil

   func TestIsNil(t *testing.T) {
       var s *string
       assert.With(t).
           That(s).
           IsNil()
   }
   

   func TestIsNotNil(t *testing.T) {
       var s string
       assert.With(t).
           That(s).
           IsNotNil()
   }
   

5. IsOk

   func TestIsOk(t *testing.T) {
       f, err := io.Open("filename.ext")
       assert.With(t).
           That(err).
           IsOk()
   }
   

6. ThatPanics

   func TestThatPanics(t *testing.T) {
       f := func() {
           panic("error")
       }
       assert.With(t).
           ThatPanics(f)
   }
   

Documentation

Index

• type Matcher
  • func With(t *testing.T) *Matcher
  • func (m *Matcher) IsEmpty() *Matcher
  • func (m *Matcher) IsEqualTo(expected interface{}) *Matcher
  • func (m *Matcher) IsGreaterThan(expected interface{}) *Matcher
  • func (m *Matcher) IsNil() *Matcher
  • func (m *Matcher) IsNotEmpty() *Matcher
  • func (m *Matcher) IsNotNil() *Matcher
  • func (m *Matcher) IsOk() *Matcher
  • func (m *Matcher) That(actual interface{}) *Matcher
  • func (m *Matcher) ThatPanics(actual func())

Types

type Matcher

type Matcher struct {
	// contains filtered or unexported fields
}

Matcher hold the current state of the assertion.

func With

func With(t *testing.T) *Matcher

With creates a new Matcher with the current test reporter.

func (*Matcher) IsEmpty

func (m *Matcher) IsEmpty() *Matcher

IsEmpty matches an empty string.

func (*Matcher) IsEqualTo

func (m *Matcher) IsEqualTo(expected interface{}) *Matcher

IsEqualTo verifies that the actual value capture in `That()` is equal to the expected value.

func (*Matcher) IsGreaterThan

func (m *Matcher) IsGreaterThan(expected interface{}) *Matcher

IsGreaterThan matches if the actual value is greater than the expected value.

func (*Matcher) IsNil

func (m *Matcher) IsNil() *Matcher

IsNil verifies the tested valid is `nil`

func (*Matcher) IsNotEmpty

func (m *Matcher) IsNotEmpty() *Matcher

IsNotEmpty matches a non-empty string.

func (*Matcher) IsNotNil

func (m *Matcher) IsNotNil() *Matcher

IsNotNil verifies the tested value is not `nil`

func (*Matcher) IsOk

func (m *Matcher) IsOk() *Matcher

IsOk expects the actual value to be nil and the type to be an instance of error.

func (*Matcher) That

func (m *Matcher) That(actual interface{}) *Matcher

That specifies the actual value under test.

func (*Matcher) ThatPanics

func (m *Matcher) ThatPanics(actual func())