From 3cf0926564e4b2e9646e212ed6b5e935970e2f8f Mon Sep 17 00:00:00 2001 From: Oleksandr Redko Date: Mon, 16 Dec 2024 22:27:38 +0200 Subject: [PATCH] docs: Format examples in README --- README.md | 185 ++++++++++++++++++++++++++---------------------------- 1 file changed, 88 insertions(+), 97 deletions(-) diff --git a/README.md b/README.md index d4857d38f..44d40e6c4 100644 --- a/README.md +++ b/README.md @@ -38,30 +38,27 @@ See it in action: package yours import ( - "testing" - "github.com/stretchr/testify/assert" + "testing" + + "github.com/stretchr/testify/assert" ) func TestSomething(t *testing.T) { + // assert equality + assert.Equal(t, 123, 123, "they should be equal") - // assert equality - assert.Equal(t, 123, 123, "they should be equal") - - // assert inequality - assert.NotEqual(t, 123, 456, "they should not be equal") - - // assert for nil (good for errors) - assert.Nil(t, object) + // assert inequality + assert.NotEqual(t, 123, 456, "they should not be equal") - // assert for not nil (good when you expect something) - if assert.NotNil(t, object) { - - // now we know that object isn't nil, we are safe to make - // further assertions without causing any errors - assert.Equal(t, "Something", object.Value) - - } + // assert for nil (good for errors) + assert.Nil(t, object) + // assert for not nil (good when you expect something) + if assert.NotNil(t, object) { + // now we know that object isn't nil, we are safe to make + // further assertions without causing any errors + assert.Equal(t, "Something", object.Value) + } } ``` @@ -74,29 +71,29 @@ if you assert many times, use the below: package yours import ( - "testing" - "github.com/stretchr/testify/assert" + "testing" + + "github.com/stretchr/testify/assert" ) func TestSomething(t *testing.T) { - assert := assert.New(t) + assert := assert.New(t) - // assert equality - assert.Equal(123, 123, "they should be equal") + // assert equality + assert.Equal(123, 123, "they should be equal") - // assert inequality - assert.NotEqual(123, 456, "they should not be equal") + // assert inequality + assert.NotEqual(123, 456, "they should not be equal") - // assert for nil (good for errors) - assert.Nil(object) + // assert for nil (good for errors) + assert.Nil(object) - // assert for not nil (good when you expect something) - if assert.NotNil(object) { - - // now we know that object isn't nil, we are safe to make - // further assertions without causing any errors - assert.Equal("Something", object.Value) - } + // assert for not nil (good when you expect something) + if assert.NotNil(object) { + // now we know that object isn't nil, we are safe to make + // further assertions without causing any errors + assert.Equal("Something", object.Value) + } } ``` @@ -120,8 +117,9 @@ An example test function that tests a piece of code that relies on an external o package yours import ( - "testing" - "github.com/stretchr/testify/mock" + "testing" + + "github.com/stretchr/testify/mock" ) /* @@ -130,8 +128,8 @@ import ( // MyMockedObject is a mocked object that implements an interface // that describes an object that the code I am testing relies on. -type MyMockedObject struct{ - mock.Mock +type MyMockedObject struct { + mock.Mock } // DoSomething is a method on MyMockedObject that implements some interface @@ -142,10 +140,8 @@ type MyMockedObject struct{ // // NOTE: This method is not being tested here, code that uses this object is. func (m *MyMockedObject) DoSomething(number int) (bool, error) { - - args := m.Called(number) - return args.Bool(0), args.Error(1) - + args := m.Called(number) + return args.Bool(0), args.Error(1) } /* @@ -155,20 +151,17 @@ func (m *MyMockedObject) DoSomething(number int) (bool, error) { // TestSomething is an example of how to use our test object to // make assertions about some target code we are testing. func TestSomething(t *testing.T) { + // create an instance of our test object + testObj := new(MyMockedObject) - // create an instance of our test object - testObj := new(MyMockedObject) - - // set up expectations - testObj.On("DoSomething", 123).Return(true, nil) - - // call the code we are testing - targetFuncThatDoesSomethingWithObj(testObj) - - // assert that the expectations were met - testObj.AssertExpectations(t) + // set up expectations + testObj.On("DoSomething", 123).Return(true, nil) + // call the code we are testing + targetFuncThatDoesSomethingWithObj(testObj) + // assert that the expectations were met + testObj.AssertExpectations(t) } // TestSomethingWithPlaceholder is a second example of how to use our test object to @@ -177,45 +170,42 @@ func TestSomething(t *testing.T) { // data being passed in is normally dynamically generated and cannot be // predicted beforehand (eg. containing hashes that are time sensitive) func TestSomethingWithPlaceholder(t *testing.T) { + // create an instance of our test object + testObj := new(MyMockedObject) - // create an instance of our test object - testObj := new(MyMockedObject) - - // set up expectations with a placeholder in the argument list - testObj.On("DoSomething", mock.Anything).Return(true, nil) + // set up expectations with a placeholder in the argument list + testObj.On("DoSomething", mock.Anything).Return(true, nil) - // call the code we are testing - targetFuncThatDoesSomethingWithObj(testObj) - - // assert that the expectations were met - testObj.AssertExpectations(t) + // call the code we are testing + targetFuncThatDoesSomethingWithObj(testObj) + // assert that the expectations were met + testObj.AssertExpectations(t) } // TestSomethingElse2 is a third example that shows how you can use // the Unset method to cleanup handlers and then add new ones. func TestSomethingElse2(t *testing.T) { + // create an instance of our test object + testObj := new(MyMockedObject) - // create an instance of our test object - testObj := new(MyMockedObject) - - // set up expectations with a placeholder in the argument list - mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil) + // set up expectations with a placeholder in the argument list + mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil) - // call the code we are testing - targetFuncThatDoesSomethingWithObj(testObj) + // call the code we are testing + targetFuncThatDoesSomethingWithObj(testObj) - // assert that the expectations were met - testObj.AssertExpectations(t) + // assert that the expectations were met + testObj.AssertExpectations(t) - // remove the handler now so we can add another one that takes precedence - mockCall.Unset() + // remove the handler now so we can add another one that takes precedence + mockCall.Unset() - // return false now instead of true - testObj.On("DoSomething", mock.Anything).Return(false, nil) + // return false now instead of true + testObj.On("DoSomething", mock.Anything).Return(false, nil) - testObj.AssertExpectations(t) + testObj.AssertExpectations(t) } ``` @@ -235,35 +225,36 @@ An example suite is shown below: ```go // Basic imports import ( - "testing" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/suite" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" ) // Define the suite, and absorb the built-in basic suite // functionality from testify - including a T() method which // returns the current testing context type ExampleTestSuite struct { - suite.Suite - VariableThatShouldStartAtFive int + suite.Suite + VariableThatShouldStartAtFive int } // Make sure that VariableThatShouldStartAtFive is set to five // before each test func (suite *ExampleTestSuite) SetupTest() { - suite.VariableThatShouldStartAtFive = 5 + suite.VariableThatShouldStartAtFive = 5 } // All methods that begin with "Test" are run as tests within a // suite. func (suite *ExampleTestSuite) TestExample() { - assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive) + assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive) } // In order for 'go test' to run this suite, we need to create // a normal test function and pass our suite to suite.Run func TestExampleTestSuite(t *testing.T) { - suite.Run(t, new(ExampleTestSuite)) + suite.Run(t, new(ExampleTestSuite)) } ``` @@ -276,33 +267,34 @@ For more information on writing suites, check out the [API documentation for the ```go // Basic imports import ( - "testing" - "github.com/stretchr/testify/suite" + "testing" + + "github.com/stretchr/testify/suite" ) // Define the suite, and absorb the built-in basic suite // functionality from testify - including assertion methods. type ExampleTestSuite struct { - suite.Suite - VariableThatShouldStartAtFive int + suite.Suite + VariableThatShouldStartAtFive int } // Make sure that VariableThatShouldStartAtFive is set to five // before each test func (suite *ExampleTestSuite) SetupTest() { - suite.VariableThatShouldStartAtFive = 5 + suite.VariableThatShouldStartAtFive = 5 } // All methods that begin with "Test" are run as tests within a // suite. func (suite *ExampleTestSuite) TestExample() { - suite.Equal(suite.VariableThatShouldStartAtFive, 5) + suite.Equal(suite.VariableThatShouldStartAtFive, 5) } // In order for 'go test' to run this suite, we need to create // a normal test function and pass our suite to suite.Run func TestExampleTestSuite(t *testing.T) { - suite.Run(t, new(ExampleTestSuite)) + suite.Run(t, new(ExampleTestSuite)) } ``` @@ -329,14 +321,13 @@ Import the `testify/assert` package into your code using this template: package yours import ( - "testing" - "github.com/stretchr/testify/assert" + "testing" + + "github.com/stretchr/testify/assert" ) func TestSomething(t *testing.T) { - - assert.True(t, true, "True is true!") - + assert.True(t, true, "True is true!") } ```