GoConvey comes with a lot of standard assertions you can use with So().

General Equality

  1. So(thing1, ShouldEqual, thing2)
  2. So(thing1, ShouldNotEqual, thing2)
  3. So(thing1, ShouldResemble, thing2)        // a deep equals for arrays, slices, maps, and structs
  4. So(thing1, ShouldNotResemble, thing2)
  5. So(thing1, ShouldPointTo, thing2)
  6. So(thing1, ShouldNotPointTo, thing2)
  7. So(thing1, ShouldBeNil)
  8. So(thing1, ShouldNotBeNil)
  9. So(thing1, ShouldBeTrue)
  10. So(thing1, ShouldBeFalse)
  11. So(thing1, ShouldBeZeroValue)

Numeric Quantity comparison

  1. So(1, ShouldBeGreaterThan, 0)
  2. So(1, ShouldBeGreaterThanOrEqualTo, 0)
  3. So(1, ShouldBeLessThan, 2)
  4. So(1, ShouldBeLessThanOrEqualTo, 2)
  5. So(1.1, ShouldBeBetween, .8, 1.2)
  6. So(1.1, ShouldNotBeBetween, 2, 3)
  7. So(1.1, ShouldBeBetweenOrEqual, .9, 1.1)
  8. So(1.1, ShouldNotBeBetweenOrEqual, 1000, 2000)
  9. So(1.0, ShouldAlmostEqual, 0.99999999, .0001)   // tolerance is optional; default 0.0000000001
  10. So(1.0, ShouldNotAlmostEqual, 0.9, .0001)

Collections

  1. So([]int{2, 4, 6}, ShouldContain, 4)
  2. So([]int{2, 4, 6}, ShouldNotContain, 5)
  3. So(4, ShouldBeIn, ...[]int{2, 4, 6})
  4. So(4, ShouldNotBeIn, ...[]int{1, 3, 5})
  5. So([]int{}, ShouldBeEmpty)
  6. So([]int{1}, ShouldNotBeEmpty)
  7. So(map[string]string{"a": "b"}, ShouldContainKey, "a")
  8. So(map[string]string{"a": "b"}, ShouldNotContainKey, "b")
  9. So(map[string]string{"a": "b"}, ShouldNotBeEmpty)
  10. So(map[string]string{}, ShouldBeEmpty)
  11. So(map[string]string{"a": "b"}, ShouldHaveLength, 1) // supports map, slice, chan, and string

Strings

  1. So("asdf", ShouldStartWith, "as")
  2. So("asdf", ShouldNotStartWith, "df")
  3. So("asdf", ShouldEndWith, "df")
  4. So("asdf", ShouldNotEndWith, "df")
  5. So("asdf", ShouldContainSubstring, "sd")        // optional 'expected occurences' arguments?
  6. So("asdf", ShouldNotContainSubstring, "er")
  7. So("adsf", ShouldBeBlank)
  8. So("asdf", ShouldNotBeBlank)

panic

  1. So(func(), ShouldPanic)
  2. So(func(), ShouldNotPanic)
  3. So(func(), ShouldPanicWith, "")        // or errors.New("something")
  4. So(func(), ShouldNotPanicWith, "")    // or errors.New("something")

Type checking

  1. So(1, ShouldHaveSameTypeAs, 0)
  2. So(1, ShouldNotHaveSameTypeAs, "asdf")

time.Time (and time.Duration)

  1. So(time.Now(), ShouldHappenBefore, time.Now())
  2. So(time.Now(), ShouldHappenOnOrBefore, time.Now())
  3. So(time.Now(), ShouldHappenAfter, time.Now())
  4. So(time.Now(), ShouldHappenOnOrAfter, time.Now())
  5. So(time.Now(), ShouldHappenBetween, time.Now(), time.Now())
  6. So(time.Now(), ShouldHappenOnOrBetween, time.Now(), time.Now())
  7. So(time.Now(), ShouldNotHappenOnOrBetween, time.Now(), time.Now())
  8. So(time.Now(), ShouldHappenWithin, duration, time.Now())
  9. So(time.Now(), ShouldNotHappenWithin, duration, time.Now())

Thanks to github.com/jacobsa for his excellentoglematchers library, whichis what many of these methods make use of to do their jobs.

Next

Next up, learn about building your own assertions.