assertion

lightwight test environment

Description

test environment

Programming language: Go

Tags: Testing     Testing Frameworks     Tools    

Latest version: v1.0

README

Should

lightweight test environment

Install

go get github.com/maprost/should

Supported methods

• should.BeEqual(t, element, element) -> check if two elements are equal
• should.NotBeEqual(t,element, element) -> check if two elements are not equal
• should.BeNil(t,element) -> check if an element it nil
• should.NotBeNilt,(element) -> check if an element is not nil
• should.BeTrue(t,element) -> check if an element is true
• should.BeFalse(t,element) -> check if an element is false
• should.HaveLength(t,collection, length) -> (only for array/slice/map) check the length of the collection
• should.Contain(t,collection, element) -> (only for array/slice/map/string) check if the collection contains the element
• should.NotContain(t,collection, element) -> (only for array/slice/map) check if the collection contains not the element
• should.BeSimilar(t,collection, collection) -> (only for array/slice) check if the two collections contains the same elements
• should.NotBeSimilar(t,collection, collection) -> (only for array/slice) check if the two collections contains at least one different element
• should.Fail -> stops the tests with the given error message

Usage

Please look into the test files to see the possibilities. For the first look here some examples:

func TestSimple(t *testing.T) {
    should.BeEqual(t, 1, 1, "should be equal")
    should.BeNil(t, nil)
    should.NotBeNil(t, 1)
    should.BeTrue(t, true)
    should.BeFalse(t, false)
    should.NotBeEqual(t, 1, 2)
    should.NotBeEqual(t, 1.0, 1)
    should.NotBeEqual(t, int64(1), int32(1))
}

func TestDataStructures(t *testing.T) {
    should.HaveLength(t, []int{1, 2, 3}, 3)
    should.HaveLength(t, [3]int{1, 2, 3}, 3)
    should.HaveLength(t, map[int]int{1: 1, 2: 3, 3: 5}, 3)
    should.BeEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
    should.NotBeEqual(t, []int{1, 2, 3}, []int{3, 2, 1})
    should.BeSimilar(t, []int{1, 2, 3}, []int{3, 2, 1})
    should.BeSimilar(t, []int{1, 2, 3}, [3]int{3, 2, 1})
    should.NotBeSimilar(t, []int{1, 2, 3}, [3]int{3, 2, 4})
    should.NotBeSimilar(t, []int{1, 2, 3}, []int{2, 3, 4, 1})
    should.NotBeEqual(t, []int{1, 2, 3}, [3]int{1, 2, 3})
    should.BeEqual(t, [3]int{1, 2, 3}, [3]int{1, 2, 3})
    should.Contain(t, []int{1, 2, 3}, 2)
    should.NotContain(t, []int{1, 2, 3}, 4)
    should.Contain(t, [3]int{1, 2, 3}, 3)
    should.NotContain(t, [3]int{1, 2, 3}, 4)
    should.BeEqual(t, map[int]string{1: "1", 2: "2", 3: "3"}, map[int]string{1: "1", 2: "2", 3: "3"})
    should.NotBeEqual(t, map[int]string{1: "1", 3: "3"}, map[int]string{1: "1", 4: "4"})
    should.BeEqual(t, map[int]string{1: "1", 3: "3"}, map[int]string{3: "3", 1: "1"})
    should.Contain(t, map[int]string{1: "11", 3: "33"}, "33")
    should.NotContain(t, map[int]string{1: "11", 3: "33"}, "55")
}

func TestStructs(t *testing.T) {
    type Post struct {
        Id  int64
        Msg string
    }

    p1 := Post{Id: 12, Msg: "New"}
    p2 := Post{Id: 12, Msg: "New"}
    p3 := Post{Id: 12, Msg: "Old"}

    should.BeEqual(t, p1, p1)
    should.BeEqual(t, p1, p2)
    should.BeEqual(t, &p1, &p2)
    should.NotBeEqual(t, p1, p3)
    should.NotBeEqual(t, p1, &p1)

    should.BeEqual(t, []Post{p1}, []Post{p2})
    should.NotBeEqual(t, []Post{p1}, []Post{p3})
    should.Contain(t, []Post{p1, p2, p3}, p3)
    should.Contain(t, []*Post{&p1, &p2, &p3}, &p3)
    should.Contain(t, []*Post{&p1, &p3}, &p2)
    should.NotContain(t, []Post{p1, p2}, p3)
    should.NotContain(t, []Post{p1}, 22)
    should.NotContain(t, []Post{}, p1)
    should.NotContain(t, []*Post{&p1, &p2}, &p3)
    should.NotContain(t, []*Post{&p1, &p2}, p2)

    should.BeEqual(t, [1]Post{p1}, [1]Post{p2})
    should.NotBeEqual(t, [1]Post{p1}, [1]Post{p3})
    should.Contain(t, [2]Post{p1, p2}, p2)
    should.Contain(t, [3]*Post{&p1, &p2, &p3}, &p3)
    should.Contain(t, [2]*Post{&p1, &p3}, &p2)
    should.NotContain(t, [2]Post{p1, p2}, p3)
    should.NotContain(t, [1]Post{p1}, "blob")
    should.NotContain(t, [0]Post{}, p1)
    should.NotContain(t, [2]*Post{&p1, &p2}, &p3)
    should.NotContain(t, [2]*Post{&p1, &p2}, p1)

    should.BeEqual(t, map[int]Post{1: p1}, map[int]Post{1: p2})
    should.NotBeEqual(t, map[int]Post{1: p1}, map[int]Post{1: p3})
    should.NotBeEqual(t, map[int]Post{1: p1}, map[int]Post{2: p1})
    should.Contain(t, map[int]Post{1: p1, 2: p2}, p2)
    should.Contain(t, map[int]*Post{1: &p1, 2: &p2}, &p2)
    should.NotContain(t, map[int]Post{1: p1, 2: p2}, p3)
    should.NotContain(t, map[int]Post{1: p1}, "blob")
    should.NotContain(t, map[int]Post{}, p1)
    should.NotContain(t, map[int]*Post{1: &p1}, p1)
}

Output

The output of a failed test shows you the actual and expected value and a stacktrace.

should.go:75: Not equal:
      actual: 1(float64)
    expected: 1(int)
    /.../src/github.com/maprost/should/failing_test.go:12 +0xd1
    /usr/local/go/src/testing/testing.go:657 +0x96
    /usr/local/go/src/testing/testing.go:697 +0x2ca