From 5a085ebad4f802c6d1a04dd8714ea19a3f14cdca Mon Sep 17 00:00:00 2001 From: Obszczymucha Date: Mon, 2 Jan 2023 17:27:35 +1100 Subject: [PATCH] Add method prefix and test prefix/suffix options. --- luaunit.lua | 100 +++++++++++++++++--------- test/test_luaunit.lua | 159 +++++++++++++++++++++++------------------- 2 files changed, 154 insertions(+), 105 deletions(-) diff --git a/luaunit.lua b/luaunit.lua index 4741478b..acfcb660 100755 --- a/luaunit.lua +++ b/luaunit.lua @@ -76,25 +76,28 @@ M.SKIP_PREFIX = 'LuaUnit test SKIP: ' -- prefix string for skipped tests M.USAGE=[[Usage: lua [options] [testname1 [testname2] ... ] Options: - -h, --help: Print this help - --version: Print version information - -v, --verbose: Increase verbosity - -q, --quiet: Set verbosity to minimum - -e, --error: Stop on first error - -f, --failure: Stop on first failure or error - -s, --shuffle: Shuffle tests before running them - -o, --output OUTPUT: Set output type to OUTPUT - Possible values: text, tap, junit, nil - -n, --name NAME: For junit only, mandatory name of xml file - -r, --repeat NUM: Execute all tests NUM times, e.g. to trig the JIT - -p, --pattern PATTERN: Execute all test names matching the Lua PATTERN - May be repeated to include several patterns - Make sure you escape magic chars like +? with % - -x, --exclude PATTERN: Exclude all test names matching the Lua PATTERN - May be repeated to exclude several patterns - Make sure you escape magic chars like +? with % - testname1, testname2, ... : tests to run in the form of testFunction, - TestClass or TestClass.testMethod + -h, --help: Print this help + --version: Print version information + -v, --verbose: Increase verbosity + -q, --quiet: Set verbosity to minimum + -e, --error: Stop on first error + -f, --failure: Stop on first failure or error + -s, --shuffle: Shuffle tests before running them + -o, --output OUTPUT: Set output type to OUTPUT + Possible values: text, tap, junit, nil + -n, --name NAME: For junit only, mandatory name of xml file + -r, --repeat NUM: Execute all tests NUM times, e.g. to trig the JIT + -p, --pattern PATTERN: Execute all test names matching the Lua PATTERN + May be repeated to include several patterns + Make sure you escape magic chars like +? with % + -x, --exclude PATTERN: Exclude all test names matching the Lua PATTERN + May be repeated to exclude several patterns + Make sure you escape magic chars like +? with % + -m, --method-prefix PREFIX: Execute methods that start with the PREFIX (default: test) + -t, --test-prefix PREFIX: Execute tests that start with the PREFIX (default: test) + -T, --test-suffix SUFFIX: Execute tests that end with the SUFFIX + testname1, testname2, ... : tests to run in the form of testFunction, + TestClass or TestClass.testMethod You may also control LuaUnit options with the following environment variables: * LUAUNIT_OUTPUT: same as --output @@ -2531,28 +2534,32 @@ end return nil, someName end - function M.LuaUnit.isMethodTestName( s ) + function M.LuaUnit:isMethodTestName( s ) -- return true is the name matches the name of a test method -- default rule is that is starts with 'Test' or with 'test' - return string.sub(s, 1, 4):lower() == 'test' + local prefix = self.methodPrefix or 'test' + return string.sub(s, 1, #prefix):lower() == prefix:lower() end - function M.LuaUnit.isTestName( s ) + function M.LuaUnit:isTestName( s ) -- return true is the name matches the name of a test - -- default rule is that is starts with 'Test' or with 'test' - return string.sub(s, 1, 4):lower() == 'test' + -- default ruleeis that is starts with 'Test' or with 'test' + local prefix = self.testPrefix or 'test' + return string.sub(s, 1, #prefix):lower() == prefix:lower() or + self.testSuffix and s:sub(-#self.testSuffix) == self.testSuffix or false end - function M.LuaUnit.collectTests() + function M.LuaUnit:collectTests() -- return a list of all test names in the global namespace -- that match LuaUnit.isTestName local testNames = {} for k, _ in pairs(_G) do - if type(k) == "string" and M.LuaUnit.isTestName( k ) then + if type(k) == "string" and self:isTestName( k ) then table.insert( testNames , k ) end end + table.sort( testNames ) return testNames end @@ -2566,6 +2573,9 @@ end -- --output, -o, + name: select output type -- --pattern, -p, + pattern: run test matching pattern, may be repeated -- --exclude, -x, + pattern: run test not matching pattern, may be repeated + -- --method-prefix, -m, + prefix: prefix of test methods (default: test) + -- --test-prefix, -t, + prefix: prefix of tests (default: test) + -- --test-suffix, -T, + suffix: suffix of tests -- --shuffle, -s, : shuffle tests before reunning them -- --name, -n, + fname: name of output file for junit, default to stdout -- --repeat, -r, + num: number of times to execute each test @@ -2585,6 +2595,9 @@ end local SET_EXCLUDE = 3 local SET_FNAME = 4 local SET_REPEAT = 5 + local SET_METHOD_PREFIX = 6 + local SET_TEST_PREFIX = 7 + local SET_TEST_SUFFIX = 8 if cmdLine == nil then return result @@ -2627,6 +2640,15 @@ end elseif option == '--exclude' or option == '-x' then state = SET_EXCLUDE return state + elseif option == '--method-prefix' or option == '-m' then + state = SET_METHOD_PREFIX + return state + elseif option == '--test-prefix' or option == '-t' then + state = SET_TEST_PREFIX + return state + elseif option == '--test-suffix' or option == '-T' then + state = SET_TEST_SUFFIX + return state end error('Unknown option: '..option,3) end @@ -2657,6 +2679,15 @@ end result['pattern'] = { notArg } end return + elseif state == SET_METHOD_PREFIX then + result['methodPrefix'] = cmdArg + return + elseif state == SET_TEST_PREFIX then + result['testPrefix'] = cmdArg + return + elseif state == SET_TEST_SUFFIX then + result['testSuffix'] = cmdArg + return end error('Unknown parse state: '.. state) end @@ -3115,21 +3146,21 @@ end self:endTest() end - function M.LuaUnit.expandOneClass( result, className, classInstance ) + function M.LuaUnit:expandOneClass( result, className, classInstance ) --[[ Input: a list of { name, instance }, a class name, a class instance Ouptut: modify result to add all test method instance in the form: { className.methodName, classInstance } ]] for methodName, methodInstance in sortedPairs(classInstance) do - if M.LuaUnit.asFunction(methodInstance) and M.LuaUnit.isMethodTestName( methodName ) then + if M.LuaUnit.asFunction(methodInstance) and self:isMethodTestName( methodName ) then table.insert( result, { className..'.'..methodName, classInstance } ) end end end - - function M.LuaUnit.expandClasses( listOfNameAndInst ) + function M.LuaUnit:expandClasses( listOfNameAndInst ) --[[ + -- expand all classes (provided as {className, classInstance}) to a list of {className.methodName, classInstance} -- functions and methods remain untouched @@ -3158,7 +3189,7 @@ end end table.insert( result, { name, instance } ) else - M.LuaUnit.expandOneClass( result, name, instance ) + self:expandOneClass( result, name, instance ) end end end @@ -3228,7 +3259,7 @@ end This function is internal to LuaUnit. The official API to perform this action is runSuiteByInstances() ]] - local expandedList = self.expandClasses( listOfNameAndInst ) + local expandedList = self:expandClasses( listOfNameAndInst ) if self.shuffle then randomizeTable( expandedList ) end @@ -3393,6 +3424,9 @@ end self.exeRepeat = options.exeRepeat self.patternIncludeFilter = options.pattern self.shuffle = options.shuffle + self.methodPrefix = self.methodPrefix or options.methodPrefix + self.testPrefix = self.testPrefix or options.testPrefix + self.testSuffix = self.testSuffix or options.testSuffix options.output = options.output or os.getenv('LUAUNIT_OUTPUT') options.fname = options.fname or os.getenv('LUAUNIT_JUNIT_FNAME') @@ -3411,7 +3445,7 @@ end function M.LuaUnit:runSuite( ... ) testNames = self:initFromArguments(...) self:registerSuite() - self:internalRunSuiteByNames( testNames or M.LuaUnit.collectTests() ) + self:internalRunSuiteByNames( testNames or self:collectTests() ) self:unregisterSuite() return self.result.notSuccessCount end diff --git a/test/test_luaunit.lua b/test/test_luaunit.lua index 10fa0198..d0e3a061 100644 --- a/test/test_luaunit.lua +++ b/test/test_luaunit.lua @@ -67,6 +67,12 @@ TestMock = {} lu.assertEquals( #m.calls, 2 ) end +local function mockedRunner() + local runner = lu.LuaUnit.new() + runner.testPrefix = 'MyTest' + return runner +end + ------------------------------------------------------------------ -- -- Utility Tests @@ -681,11 +687,11 @@ bar"=1}]] ) end function TestLuaUnitUtilities:test_isTestName() - lu.assertEquals( lu.LuaUnit.isTestName( 'testToto' ), true ) - lu.assertEquals( lu.LuaUnit.isTestName( 'TestToto' ), true ) - lu.assertEquals( lu.LuaUnit.isTestName( 'TESTToto' ), true ) - lu.assertEquals( lu.LuaUnit.isTestName( 'xTESTToto' ), false ) - lu.assertEquals( lu.LuaUnit.isTestName( '' ), false ) + lu.assertEquals( lu.LuaUnit:isTestName( 'testToto' ), true ) + lu.assertEquals( lu.LuaUnit:isTestName( 'TestToto' ), true ) + lu.assertEquals( lu.LuaUnit:isTestName( 'TESTToto' ), true ) + lu.assertEquals( lu.LuaUnit:isTestName( 'xTESTToto' ), false ) + lu.assertEquals( lu.LuaUnit:isTestName( '' ), false ) end function TestLuaUnitUtilities:test_parseCmdLine() @@ -737,6 +743,18 @@ bar"=1}]] ) { pattern={'toto', 'tutu'}, verbosity=lu.VERBOSITY_VERBOSE, output='tintin', testNames={'titi', 'tata', 'prout'}, fname='toto.xml' } ) lu.assertErrorMsgContains( 'option: -$', lu.LuaUnit.parseCmdLine, { '-$', } ) + + -- method-prefix + lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--method-prefix', 'should' } ), { methodPrefix='should' } ) + lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-m', 'should' } ), { methodPrefix='should' } ) + lu.assertErrorMsgContains( 'Missing argument after -m', lu.LuaUnit.parseCmdLine, { '-m', } ) + + -- test-prefix + lu.assertEquals( lu.LuaUnit.parseCmdLine( { '--test-prefix', 'should' } ), { testPrefix='should' } ) + lu.assertEquals( lu.LuaUnit.parseCmdLine( { '-t', 'should' } ), { testPrefix='should' } ) + lu.assertErrorMsgContains( 'Missing argument after -t', lu.LuaUnit.parseCmdLine, { '-t', } ) + + lu.assertErrorMsgContains( 'Missing argument after -x', lu.LuaUnit.parseCmdLine, { '-x', } ) end function TestLuaUnitUtilities:test_patternFilter() @@ -846,12 +864,13 @@ bar"=1}]] ) function TestLuaUnitUtilities:test_expandOneClass() local result = {} - lu.LuaUnit.expandOneClass( result, 'titi', {} ) + local runner = mockedRunner() + runner:expandOneClass( result, 'titi', {} ) lu.assertEquals( result, {} ) result = {} - lu.LuaUnit.expandOneClass( result, 'MyTestToto1', MyTestToto1 ) - lu.assertEquals( result, { + lu.LuaUnit:expandOneClass( result, 'MyTestToto1', MyTestToto1 ) + lu.assertEquals( result, { {'MyTestToto1.test1', MyTestToto1 }, {'MyTestToto1.test2', MyTestToto1 }, {'MyTestToto1.test3', MyTestToto1 }, @@ -862,17 +881,18 @@ bar"=1}]] ) function TestLuaUnitUtilities:test_expandClasses() local result - result = lu.LuaUnit.expandClasses( {} ) + local runner = mockedRunner() + result = runner:expandClasses( {} ) lu.assertEquals( result, {} ) - result = lu.LuaUnit.expandClasses( { { 'MyTestFunction', MyTestFunction } } ) + result = runner:expandClasses( { { 'MyTestFunction', MyTestFunction } } ) lu.assertEquals( result, { { 'MyTestFunction', MyTestFunction } } ) - result = lu.LuaUnit.expandClasses( { { 'MyTestToto1.test1', MyTestToto1 } } ) + result = runner:expandClasses( { { 'MyTestToto1.test1', MyTestToto1 } } ) lu.assertEquals( result, { { 'MyTestToto1.test1', MyTestToto1 } } ) - result = lu.LuaUnit.expandClasses( { { 'MyTestToto1', MyTestToto1 } } ) - lu.assertEquals( result, { + result = runner:expandClasses( { { 'MyTestToto1', MyTestToto1 } } ) + lu.assertEquals( result, { {'MyTestToto1.test1', MyTestToto1 }, {'MyTestToto1.test2', MyTestToto1 }, {'MyTestToto1.test3', MyTestToto1 }, @@ -1052,7 +1072,7 @@ TestLuaUnitOutputters = { __class__ = 'TestOutputters' } -- JUnitOutput:startSuite() can raise errors on its own, cover those function TestLuaUnitOutputters:testJUnitOutputErrors() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType('junit') local outputter = runner.outputType.new(runner) @@ -3135,26 +3155,24 @@ MyTestOk = {} --class function MyTestOk:testOk2() end function MyTestFunction() - table.insert( executedTests, "MyTestFunction" ) + table.insert( executedTests, "MyTestFunction" ) end TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } + function TestLuaUnitExecution:tearDown() executedTests = {} - lu.LuaUnit.isTestName = lu.LuaUnit.isTestNameOld end function TestLuaUnitExecution:setUp() executedTests = {} - lu.LuaUnit.isTestNameOld = lu.LuaUnit.isTestName - lu.LuaUnit.isTestName = function( s ) return (string.sub(s,1,6) == 'MyTest') end end function TestLuaUnitExecution:oneInstanceExists() lu.assertEquals( #lu.LuaUnit.instances, 1 ) - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestToto2', 'MyTestToto1', 'MyTestFunction' ) @@ -3167,12 +3185,13 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } end function TestLuaUnitExecution:test_collectTests() - local allTests = lu.LuaUnit.collectTests() + local runner = mockedRunner() + local allTests = runner:collectTests(true) lu.assertEquals( allTests, {"MyTestFunction", "MyTestOk", "MyTestToto1", "MyTestToto2","MyTestWithErrorsAndFailures"}) end function TestLuaUnitExecution:test_MethodsAreExecutedInRightOrder() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestToto1' ) lu.assertEquals( #executedTests, 5 ) @@ -3185,7 +3204,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function TestLuaUnitExecution:test_runSuite() -- note: this also test that names are executed in explicit order - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestToto2', 'MyTestToto1', 'MyTestFunction' ) lu.assertEquals( #executedTests, 7 ) @@ -3196,7 +3215,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function TestLuaUnitExecution:testRunSomeTestByGlobalInstance( ) lu.assertEquals( #executedTests, 0 ) - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'Toto', MyTestToto1 } }, 'fake_run_unit_tests.lua' ) lu.assertEquals( #executedTests, 5 ) @@ -3213,11 +3232,11 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyLocalTestToto2:test1() table.insert( executedTests, "MyLocalTestToto2:test1" ) end function MyLocalTestToto2:test2() table.insert( executedTests, "MyLocalTestToto2:test2" ) end local function MyLocalTestFunction() table.insert( executedTests, "MyLocalTestFunction" ) end - + lu.assertEquals( #executedTests, 0 ) - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) - runner:runSuiteByInstances( { + runner:runSuiteByInstances( { { 'MyLocalTestToto1', MyLocalTestToto1 }, { 'MyLocalTestToto2.test2', MyLocalTestToto2 }, { 'MyLocalTestFunction', MyLocalTestFunction }, @@ -3229,7 +3248,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } end function TestLuaUnitExecution:testRunReturnsNumberOfFailures() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) local ret = runner:runSuite( 'MyTestWithErrorsAndFailures' ) lu.assertEquals(ret, 3) @@ -3239,7 +3258,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } end function TestLuaUnitExecution:testTestCountAndFailCount() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestWithErrorsAndFailures' ) lu.assertEquals( runner.result.selectedCount, 4) @@ -3282,7 +3301,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupTeardown5:test1() table.insert( myExecutedTests, '5test1' ) end function MyTestWithSetupTeardown5:TearDown() table.insert( myExecutedTests, '5TearDown' ) end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupTeardown.test1', MyTestWithSetupTeardown } } ) lu.assertEquals( runner.result.notSuccessCount, 0 ) @@ -3329,7 +3348,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3350,7 +3369,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3372,7 +3391,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3394,7 +3413,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) lu.assertEquals( 'b', 'c') end function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3416,7 +3435,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupFailure:test1() table.insert( myExecutedTests, 'test1' ) lu.assertEquals( 'b', 'c') end function MyTestWithSetupFailure:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'b', 'c') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupFailure', MyTestWithSetupFailure } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3439,7 +3458,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3460,7 +3479,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3482,7 +3501,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3504,7 +3523,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) error('test error') end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3526,7 +3545,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) error('test error') end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3549,7 +3568,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3572,7 +3591,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'a', 'b') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3595,7 +3614,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) error('test error') end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) lu.assertEquals( 'a', 'b') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3619,7 +3638,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function MyTestWithSetupError:test1() table.insert( myExecutedTests, 'test1' ) lu.assertEquals( 'a', 'b') end function MyTestWithSetupError:tearDown() table.insert( myExecutedTests, 'tearDown' ) error('teardown error') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'MyTestWithSetupError', MyTestWithSetupError } } ) lu.assertEquals( runner.result.notSuccessCount, 1 ) @@ -3644,24 +3663,23 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } local MyTestClassA = { test1 = function() table.insert( myExecutedTests, 'Atest1' ) end } - + local MyTestClassB = { test1 = function() table.insert( myExecutedTests, 'Btest1' ) end } - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner.patternIncludeFilter = {"test"} - - runner:internalRunSuiteByInstances( { + runner:internalRunSuiteByInstances( { { 'setupSuite', setupSuite }, { 'teardownSuite', teardownSuite }, { 'MyTestClassA', MyTestClassA }, { 'MyTestClassB', MyTestClassB } } ) lu.assertEquals( runner.result.notSuccessCount, 0 ) - lu.assertEquals( myExecutedTests[1], 'setupSuite' ) + lu.assertEquals( myExecutedTests[1], 'setupSuite' ) lu.assertEquals( myExecutedTests[2], 'Atest1') lu.assertEquals( myExecutedTests[3], 'Btest1') lu.assertEquals( myExecutedTests[4], 'teardownSuite') @@ -3677,7 +3695,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } test1 = function() table.insert( myExecutedTests, 'Atest1' ) end, test2 = function() table.insert( myExecutedTests, 'Atest2' ) end } - + local MyTestClassB = { setupClass = function() table.insert( myExecutedTests, 'BsetupClass' ) end, teardownClass = function() table.insert( myExecutedTests, 'BteardownClass' ) end, @@ -3685,7 +3703,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } test2 = function() table.insert( myExecutedTests, 'Btest2' ) end } - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner.patternIncludeFilter = {"test"} @@ -3742,7 +3760,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } } - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner.patternIncludeFilter = {"test"} @@ -3793,7 +3811,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } lu.fail( 'Stop early.') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_fails', my_test_fails } } ) lu.assertEquals( runner.result.selectedCount, 1 ) @@ -3811,7 +3829,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } lu.failIf( 1 == 1, 'YESSS') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_fails', my_test_fails } } ) lu.assertEquals( runner.result.selectedCount, 1 ) @@ -3828,7 +3846,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } error('toto') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_success', my_test_success } } ) lu.assertEquals( runner.result.selectedCount, 1 ) @@ -3851,7 +3869,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } error('toto') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_fails', my_test_fails }, {'my_test_success', my_test_success} } ) lu.assertEquals( runner.result.selectedCount, 2 ) @@ -3869,7 +3887,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } error('skip does not work!') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_skip', my_test_skip } } ) lu.assertEquals( runner.result.selectedCount, 1 ) @@ -3893,7 +3911,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } error('toto') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_skip', my_test_skip }, {'my_test_no_skip', my_test_no_skip} } ) lu.assertEquals( runner.result.selectedCount, 2 ) @@ -3919,7 +3937,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } error('toto') end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances( { { 'my_test_run_only_if', my_test_run_only_if }, {'my_test_not_run_only_if', my_test_not_run_only_if} } ) lu.assertEquals( runner.result.selectedCount, 2 ) @@ -3934,7 +3952,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function TestLuaUnitExecution:testWithRepeat() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) local nbIter = 0 @@ -3994,7 +4012,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function TestLuaUnitExecution:testOutputInterface() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner.outputType = Mock runner:runSuite( 'MyTestWithErrorsAndFailures', 'MyTestOk' ) local m = runner.output @@ -4090,7 +4108,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } function TestLuaUnitExecution:testInvocation() lu.assertEquals( #lu.LuaUnit.instances, 1) - local runner = lu.LuaUnit.new() + local runner = mockedRunner() -- this does not create a new registered instance lu.assertEquals( #lu.LuaUnit.instances, 1) @@ -4124,16 +4142,16 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } runner.runSuite, runner, 'MyTestOk.foobar') lu.assertEquals( #lu.LuaUnit.instances, 1) lu.assertErrorMsgContains('Instance must be a table or a function', - runner.expandClasses, {{'foobar', 'INVALID'}}) + runner.expandClasses, runner, {{'foobar', 'INVALID'}}) lu.assertEquals( #lu.LuaUnit.instances, 1) lu.assertErrorMsgContains('Could not find method in class', - runner.expandClasses, {{'MyTestOk.foobar', {}}}) + runner.expandClasses, runner, {{'MyTestOk.foobar', {}}}) lu.assertEquals( #lu.LuaUnit.instances, 1) end function TestLuaUnitExecution:test_filterWithPattern() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite('-p', 'Function', '-p', 'Toto.' ) lu.assertEquals( executedTests[1], "MyTestFunction" ) @@ -4150,7 +4168,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } end function TestLuaUnitExecution:test_endSuiteTwice() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestWithErrorsAndFailures', 'MyTestOk' ) lu.assertErrorMsgContains('suite was already ended', @@ -4162,7 +4180,7 @@ TestLuaUnitExecution = { __class__ = 'TestLuaUnitExecution' } error {code = 123} end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuiteByInstances { { 'my_test_with_table_error', my_test_with_table_error } } lu.assertStrContains(runner.result.allTests[1].msg, '{code=123}') @@ -4180,13 +4198,10 @@ TestLuaUnitResults = { __class__ = 'TestLuaUnitResults' } function TestLuaUnitResults:tearDown() executedTests = {} - lu.LuaUnit.isTestName = lu.LuaUnit.isTestNameOld end function TestLuaUnitResults:setUp() executedTests = {} - lu.LuaUnit.isTestNameOld = lu.LuaUnit.isTestName - lu.LuaUnit.isTestName = function( s ) return (string.sub(s,1,6) == 'MyTest') end end function TestLuaUnitResults:test_statusLine() @@ -4271,7 +4286,7 @@ TestLuaUnitResults = { __class__ = 'TestLuaUnitResults' } end function TestLuaUnitResults:test_runSuiteOk() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestToto2', 'MyTestToto1', 'MyTestFunction' ) lu.assertEquals( #runner.result.allTests, 7 ) @@ -4316,7 +4331,7 @@ TestLuaUnitResults = { __class__ = 'TestLuaUnitResults' } end function TestLuaUnitResults:test_runSuiteWithFailures() - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner:setOutputType( "NIL" ) runner:runSuite( 'MyTestWithErrorsAndFailures' ) @@ -4400,7 +4415,7 @@ TestLuaUnitResults = { __class__ = 'TestLuaUnitResults' } return t end - local runner = lu.LuaUnit.new() + local runner = mockedRunner() runner.outputType = MyMocker runner:runSuite( 'MyTestWithErrorsAndFailures' )