This repository has been archived on 2019-06-23. You can view files and clone it, but cannot push or open issues or pull requests.
mumbledj/vendor/github.com/stretchr/testify/require/requirements_test.go

370 lines
7.2 KiB
Go
Raw Normal View History

package require
import (
"errors"
"testing"
"time"
)
// AssertionTesterInterface defines an interface to be used for testing assertion methods
type AssertionTesterInterface interface {
TestMethod()
}
// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
type AssertionTesterConformingObject struct {
}
func (a *AssertionTesterConformingObject) TestMethod() {
}
// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
type AssertionTesterNonConformingObject struct {
}
type MockT struct {
Failed bool
}
func (t *MockT) FailNow() {
t.Failed = true
}
func (t *MockT) Errorf(format string, args ...interface{}) {
_, _ = format, args
}
func TestImplements(t *testing.T) {
Implements(t, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
mockT := new(MockT)
Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestIsType(t *testing.T) {
IsType(t, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
mockT := new(MockT)
IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestEqual(t *testing.T) {
Equal(t, 1, 1)
mockT := new(MockT)
Equal(mockT, 1, 2)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNotEqual(t *testing.T) {
NotEqual(t, 1, 2)
mockT := new(MockT)
NotEqual(mockT, 2, 2)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestExactly(t *testing.T) {
a := float32(1)
b := float32(1)
c := float64(1)
Exactly(t, a, b)
mockT := new(MockT)
Exactly(mockT, a, c)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNotNil(t *testing.T) {
NotNil(t, new(AssertionTesterConformingObject))
mockT := new(MockT)
NotNil(mockT, nil)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNil(t *testing.T) {
Nil(t, nil)
mockT := new(MockT)
Nil(mockT, new(AssertionTesterConformingObject))
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestTrue(t *testing.T) {
True(t, true)
mockT := new(MockT)
True(mockT, false)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestFalse(t *testing.T) {
False(t, false)
mockT := new(MockT)
False(mockT, true)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestContains(t *testing.T) {
Contains(t, "Hello World", "Hello")
mockT := new(MockT)
Contains(mockT, "Hello World", "Salut")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNotContains(t *testing.T) {
NotContains(t, "Hello World", "Hello!")
mockT := new(MockT)
NotContains(mockT, "Hello World", "Hello")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestPanics(t *testing.T) {
Panics(t, func() {
panic("Panic!")
})
mockT := new(MockT)
Panics(mockT, func() {})
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNotPanics(t *testing.T) {
NotPanics(t, func() {})
mockT := new(MockT)
NotPanics(mockT, func() {
panic("Panic!")
})
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNoError(t *testing.T) {
NoError(t, nil)
mockT := new(MockT)
NoError(mockT, errors.New("some error"))
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestError(t *testing.T) {
Error(t, errors.New("some error"))
mockT := new(MockT)
Error(mockT, nil)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestEqualError(t *testing.T) {
EqualError(t, errors.New("some error"), "some error")
mockT := new(MockT)
EqualError(mockT, errors.New("some error"), "Not some error")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestEmpty(t *testing.T) {
Empty(t, "")
mockT := new(MockT)
Empty(mockT, "x")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNotEmpty(t *testing.T) {
NotEmpty(t, "x")
mockT := new(MockT)
NotEmpty(mockT, "")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestWithinDuration(t *testing.T) {
a := time.Now()
b := a.Add(10 * time.Second)
WithinDuration(t, a, b, 15*time.Second)
mockT := new(MockT)
WithinDuration(mockT, a, b, 5*time.Second)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestInDelta(t *testing.T) {
InDelta(t, 1.001, 1, 0.01)
mockT := new(MockT)
InDelta(mockT, 1, 2, 0.5)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestZero(t *testing.T) {
Zero(t, "")
mockT := new(MockT)
Zero(mockT, "x")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestNotZero(t *testing.T) {
NotZero(t, "x")
mockT := new(MockT)
NotZero(mockT, "")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestJSONEq_EqualSONString(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
if mockT.Failed {
t.Error("Check should pass")
}
}
func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
if mockT.Failed {
t.Error("Check should pass")
}
}
func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
"{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
if mockT.Failed {
t.Error("Check should pass")
}
}
func TestJSONEq_Array(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
if mockT.Failed {
t.Error("Check should pass")
}
}
func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestJSONEq_HashesNotEquivalent(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestJSONEq_ActualIsNotJSON(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `{"foo": "bar"}`, "Not JSON")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`)
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, "Not JSON", "Not JSON")
if !mockT.Failed {
t.Error("Check should fail")
}
}
func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
mockT := new(MockT)
JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
if !mockT.Failed {
t.Error("Check should fail")
}
}