From c1b496c5c9ac27956b9262b938d00fe2423ef8c8 Mon Sep 17 00:00:00 2001 From: Jon Gjengset Date: Mon, 3 Nov 2014 17:46:03 -0500 Subject: [PATCH 1/3] Ensure TearDownTest is called after Skip --- suite/suite.go | 10 ++++++---- suite/suite_test.go | 14 +++++++++----- 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/suite/suite.go b/suite/suite.go index 38ad423..029723e 100644 --- a/suite/suite.go +++ b/suite/suite.go @@ -58,11 +58,13 @@ func Run(t *testing.T, suite TestingSuite) { if setupTestSuite, ok := suite.(SetupTestSuite); ok { setupTestSuite.SetupTest() } + defer func() { + if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok { + tearDownTestSuite.TearDownTest() + } + suite.SetT(parentT) + }() method.Func.Call([]reflect.Value{reflect.ValueOf(suite)}) - if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok { - tearDownTestSuite.TearDownTest() - } - suite.SetT(parentT) }, } tests = append(tests, test) diff --git a/suite/suite_test.go b/suite/suite_test.go index 104b9f5..f0fe329 100644 --- a/suite/suite_test.go +++ b/suite/suite_test.go @@ -69,6 +69,10 @@ func (suite *SuiteTester) TestTwo() { suite.NotEqual(suite.TestTwoRunCount, beforeCount) } +func (suite *SuiteTester) TestSkip() { + suite.T().Skip() +} + // NonTestMethod does not begin with "Test", so it will not be run by // testify as a test in the suite. This is useful for creating helper // methods for your tests. @@ -91,11 +95,11 @@ func TestRunSuite(t *testing.T) { assert.Equal(t, suiteTester.SetupSuiteRunCount, 1) assert.Equal(t, suiteTester.TearDownSuiteRunCount, 1) - // There are two test methods (TestOne and TestTwo), so the - // SetupTest and TearDownTest methods (which should be run once for - // each test) should have been run twice. - assert.Equal(t, suiteTester.SetupTestRunCount, 2) - assert.Equal(t, suiteTester.TearDownTestRunCount, 2) + // There are three test methods (TestOne, TestTwo, and TestSkip), so + // the SetupTest and TearDownTest methods (which should be run once for + // each test) should have been run three times. + assert.Equal(t, suiteTester.SetupTestRunCount, 3) + assert.Equal(t, suiteTester.TearDownTestRunCount, 3) // Each test should have been run once. assert.Equal(t, suiteTester.TestOneRunCount, 1) From 576f6382c0039179b0b6b923c682d912a8cf60b0 Mon Sep 17 00:00:00 2001 From: Jon Gjengset Date: Tue, 25 Nov 2014 19:57:20 -0500 Subject: [PATCH 2/3] Add test for suite Setup/TearDown with Skip --- suite/suite_test.go | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/suite/suite_test.go b/suite/suite_test.go index f0fe329..0108123 100644 --- a/suite/suite_test.go +++ b/suite/suite_test.go @@ -2,10 +2,11 @@ package suite import ( "errors" - "github.com/stretchr/testify/assert" "io/ioutil" "os" "testing" + + "github.com/stretchr/testify/assert" ) // This suite is intended to store values to make sure that only @@ -28,18 +29,36 @@ type SuiteTester struct { NonTestMethodRunCount int } +type SuiteSkipTester struct { + // Include our basic suite logic. + Suite + + // Keep counts of how many times each method is run. + SetupSuiteRunCount int + TearDownSuiteRunCount int +} + // The SetupSuite method will be run by testify once, at the very // start of the testing suite, before any tests are run. func (suite *SuiteTester) SetupSuite() { suite.SetupSuiteRunCount++ } +func (suite *SuiteSkipTester) SetupSuite() { + suite.SetupSuiteRunCount++ + suite.T().Skip() +} + // The TearDownSuite method will be run by testify once, at the very // end of the testing suite, after all tests have been run. func (suite *SuiteTester) TearDownSuite() { suite.TearDownSuiteRunCount++ } +func (suite *SuiteSkipTester) TearDownSuite() { + suite.TearDownSuiteRunCount++ +} + // The SetupTest method will be run before every test in the suite. func (suite *SuiteTester) SetupTest() { suite.SetupTestRunCount++ @@ -108,6 +127,16 @@ func TestRunSuite(t *testing.T) { // Methods that don't match the test method identifier shouldn't // have been run at all. assert.Equal(t, suiteTester.NonTestMethodRunCount, 0) + + suiteSkipTester := new(SuiteSkipTester) + Run(t, suiteSkipTester) + + // The suite was only run once, so the SetupSuite and TearDownSuite + // methods should have each been run only once, even though SetupSuite + // called Skip() + assert.Equal(t, suiteSkipTester.SetupSuiteRunCount, 1) + assert.Equal(t, suiteSkipTester.TearDownSuiteRunCount, 1) + } type SuiteLoggingTester struct { From 81a69ed1050612dbec094cb3321f08acff677454 Mon Sep 17 00:00:00 2001 From: Jon Gjengset Date: Tue, 25 Nov 2014 19:58:50 -0500 Subject: [PATCH 3/3] Defer suite teardown to align with test teardown --- suite/suite.go | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/suite/suite.go b/suite/suite.go index 029723e..a0f0945 100644 --- a/suite/suite.go +++ b/suite/suite.go @@ -39,6 +39,11 @@ func Run(t *testing.T, suite TestingSuite) { if setupAllSuite, ok := suite.(SetupAllSuite); ok { setupAllSuite.SetupSuite() } + defer func() { + if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok { + tearDownAllSuite.TearDownSuite() + } + }() methodFinder := reflect.TypeOf(suite) tests := []testing.InternalTest{} @@ -75,10 +80,6 @@ func Run(t *testing.T, suite TestingSuite) { tests) { t.Fail() } - - if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok { - tearDownAllSuite.TearDownSuite() - } } // Filtering method according to set regular expression