7.1 پکیج testify

 1package morestrings
 2
 3import "testing"
 4
 5func TestReverseRunes(t *testing.T) {
 6    cases := []struct {
 7        in, want string
 8    }{
 9        {"Hello, world", "dlrow ,olleH"},
10        {"Hello, 世界", "界世 ,olleH"},
11        {"", ""},
12    }
13    for _, c := range cases {
14        got := ReverseRunes(c.in)
15        if got != c.want {
16            t.Errorf("ReverseRunes(%q) == %q, want %q", c.in, got, c.want)
17        }
18    }
19}

1$ cd $HOME/hello/morestrings
2
3$ go test
4
5PASS
6
7ok example/user/hello/morestrings 0.165s
8
9$

1go get github.com/stretchr/testify

1github.com/stretchr/testify/assert
2
3github.com/stretchr/testify/require
4
5github.com/stretchr/testify/mock
6
7github.com/stretchr/testify/suite
8
9github.com/stretchr/testify/http (deprecated)

 1package yours
 2
 3import (
 4"testing"
 5
 6"github.com/stretchr/testify/assert"
 7
 8)
 9
10func TestSomething(t *testing.T) {
11
12assert.True(t, true, "True is true!")
13
14}

 1package yours
 2
 3  
 4
 5import (
 6
 7"testing"
 8
 9"github.com/stretchr/testify/assert"
10
11)
12
13func TestSomething(t *testing.T) {
14
15// assert equality
16
17assert.Equal(t, 123, 123, "they should be equal")
18
19  
20// assert inequality
21
22assert.NotEqual(t, 123, 456, "they should not be equal")
23
24
25// assert for nil (good for errors)
26
27assert.Nil(t, object)
28
29
30// assert for not nil (good when you expect something)
31
32if assert.NotNil(t, object) {
33
34
35// now we know that object isn't nil, we are safe to make
36
37// further assertions without causing any errors
38
39assert.Equal(t, "Something", object.Value)
40
41
42	}
43
44
45}

 1package yours
 2
 3  
 4
 5import (
 6
 7"testing"
 8
 9"github.com/stretchr/testify/assert"
10
11)
12
13  
14
15func TestSomething(t *testing.T) {
16
17assert := assert.New(t)
18
19  
20
21// assert equality
22
23assert.Equal(123, 123, "they should be equal")
24
25  
26
27// assert inequality
28
29assert.NotEqual(123, 456, "they should not be equal")
30
31  
32
33// assert for nil (good for errors)
34
35assert.Nil(object)
36
37  
38
39// assert for not nil (good when you expect something)
40
41if assert.NotNil(object) {
42
43  
44
45// now we know that object isn't nil, we are safe to make
46
47// further assertions without causing any errors
48
49assert.Equal("Something", object.Value)
50
51	}
52
53}

1type MyTestObject struct {
2// add a Mock object instance 
3mock.Mock
4// other fields go here as normal 
5}

1func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) {
2
3args := o.Called(firstname, lastname, age)
4
5return args.Int(0), args.Error(1)
6
7}

1(12, true, "Something")

1args.Int(0) 
2args.Bool(1) 
3args.String(2)

1return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine)

  1package yours
  2
  3  
  4
  5import (
  6
  7"testing"
  8
  9"github.com/stretchr/testify/mock"
 10
 11)
 12
 13  
 14
 15/*
 16
 17Test objects
 18
 19*/
 20
 21  
 22
 23// MyMockedObject is a mocked object that implements an interface
 24
 25// that describes an object that the code I am testing relies on.
 26
 27type MyMockedObject struct{
 28
 29mock.Mock
 30
 31}
 32
 33  
 34
 35// DoSomething is a method on MyMockedObject that implements some interface
 36
 37// and just records the activity, and returns what the Mock object tells it to.
 38
 39//
 40
 41// In the real object, this method would do something useful, but since this
 42
 43// is a mocked object - we're just going to stub it out.
 44
 45//
 46
 47// NOTE: This method is not being tested here, code that uses this object is.
 48
 49func (m *MyMockedObject) DoSomething(number int) (bool, error) {
 50
 51  
 52
 53args := m.Called(number)
 54
 55return args.Bool(0), args.Error(1)
 56
 57  
 58
 59}
 60
 61  
 62
 63/*
 64
 65Actual test functions
 66
 67*/
 68
 69  
 70
 71// TestSomething is an example of how to use our test object to
 72
 73// make assertions about some target code we are testing.
 74
 75func TestSomething(t *testing.T) {
 76
 77  
 78
 79// create an instance of our test object
 80
 81testObj := new(MyMockedObject)
 82
 83  
 84
 85// setup expectations
 86
 87testObj.On("DoSomething", 123).Return(true, nil)
 88
 89  
 90
 91// call the code we are testing
 92
 93targetFuncThatDoesSomethingWithObj(testObj)
 94
 95  
 96
 97// assert that the expectations were met
 98
 99testObj.AssertExpectations(t)
100
101  
102  
103
104}
105
106  
107
108// TestSomethingWithPlaceholder is a second example of how to use our test object to
109
110// make assertions about some target code we are testing.
111
112// This time using a placeholder. Placeholders might be used when the
113
114// data being passed in is normally dynamically generated and cannot be
115
116// predicted beforehand (eg. containing hashes that are time sensitive)
117
118func TestSomethingWithPlaceholder(t *testing.T) {
119
120  
121
122// create an instance of our test object
123
124testObj := new(MyMockedObject)
125
126  
127
128// setup expectations with a placeholder in the argument list
129
130testObj.On("DoSomething", mock.Anything).Return(true, nil)
131
132  
133
134// call the code we are testing
135
136targetFuncThatDoesSomethingWithObj(testObj)
137
138  
139
140// assert that the expectations were met
141
142testObj.AssertExpectations(t)
143
144  
145  
146
147}
148
149  
150
151// TestSomethingElse2 is a third example that shows how you can use
152
153// the Unset method to cleanup handlers and then add new ones.
154
155func TestSomethingElse2(t *testing.T) {
156
157  
158
159// create an instance of our test object
160
161testObj := new(MyMockedObject)
162
163  
164
165// setup expectations with a placeholder in the argument list
166
167mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil)
168
169  
170
171// call the code we are testing
172
173targetFuncThatDoesSomethingWithObj(testObj)
174
175  
176
177// assert that the expectations were met
178
179testObj.AssertExpectations(t)
180
181  
182
183// remove the handler now so we can add another one that takes precedence
184
185mockCall.Unset()
186
187  
188
189// return false now instead of true
190
191testObj.On("DoSomething", mock.Anything).Return(false, nil)
192
193  
194
195testObj.AssertExpectations(t)
196
197}

 1// Basic imports
 2
 3import (
 4
 5"testing"
 6
 7"github.com/stretchr/testify/assert"
 8
 9"github.com/stretchr/testify/suite"
10
11)
12
13  
14
15// Define the suite, and absorb the built-in basic suite
16
17// functionality from testify - including a T() method which
18
19// returns the current testing context
20
21type ExampleTestSuite struct {
22
23suite.Suite
24
25VariableThatShouldStartAtFive int
26
27}
28
29  
30
31// Make sure that VariableThatShouldStartAtFive is set to five
32
33// before each test
34
35func (suite *ExampleTestSuite) SetupTest() {
36
37suite.VariableThatShouldStartAtFive = 5
38
39}
40
41  
42
43// All methods that begin with "Test" are run as tests within a
44
45// suite.
46
47func (suite *ExampleTestSuite) TestExample() {
48
49assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
50
51}
52
53  
54
55// In order for 'go test' to run this suite, we need to create
56
57// a normal test function and pass our suite to suite.Run
58
59func TestExampleTestSuite(t *testing.T) {
60
61suite.Run(t, new(ExampleTestSuite))
62
63}

 1// Basic imports
 2
 3import (
 4
 5"testing"
 6
 7"github.com/stretchr/testify/suite"
 8
 9)
10
11  
12
13// Define the suite, and absorb the built-in basic suite
14
15// functionality from testify - including assertion methods.
16
17type ExampleTestSuite struct {
18
19suite.Suite
20
21VariableThatShouldStartAtFive int
22
23}
24
25  
26
27// Make sure that VariableThatShouldStartAtFive is set to five
28
29// before each test
30
31func (suite *ExampleTestSuite) SetupTest() {
32
33suite.VariableThatShouldStartAtFive = 5
34
35}
36
37  
38
39// All methods that begin with "Test" are run as tests within a
40
41// suite.
42
43func (suite *ExampleTestSuite) TestExample() {
44
45suite.Equal(suite.VariableThatShouldStartAtFive, 5)
46
47}
48
49  
50
51// In order for 'go test' to run this suite, we need to create
52
53// a normal test function and pass our suite to suite.Run
54
55func TestExampleTestSuite(t *testing.T) {
56
57suite.Run(t, new(ExampleTestSuite))
58
59}