nitunit: fix `before-all` and `after-all` detection

[nit.git] / src / testing / testing_suite.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Testing from external files.
module testing_suite

import testing_base
import html
private import parse_annotations
private import realtime

redef class ToolContext
        # --pattern
        var opt_pattern = new OptionString("Only run test case with name that match pattern", "-p", "--pattern")
        # --autosav
        var opt_autosav = new OptionBool("Automatically create/update .res files for black box testing", "--autosav")
end

# Used to test nitunit test files.
class NitUnitTester

        # `ModelBuilder` used to parse test files.
        var mbuilder: ModelBuilder

        # Compile and execute `mmodule` as a test suite.
        fun test_module_unit(mmodule: MModule): TestSuite do
                var toolcontext = mbuilder.toolcontext
                var suite = new TestSuite(mmodule, toolcontext)
                # method to execute before all tests in the module
                for mmethod in mmodule.before_all do
                        toolcontext.modelbuilder.total_tests += 1
                        suite.before_all.add new TestCase(suite, mmethod, toolcontext)
                end
                # generate all test cases
                for mclassdef in mmodule.mclassdefs do
                        if not mclassdef.is_test then continue
                        if not suite_match_pattern(mclassdef) then continue
                        toolcontext.modelbuilder.total_classes += 1

                        var before = mclassdef.before
                        var after = mclassdef.after

                        for mpropdef in mclassdef.mpropdefs do
                                if not mpropdef isa MMethodDef or not mpropdef.is_test then continue
                                if not case_match_pattern(mpropdef) then continue
                                toolcontext.modelbuilder.total_tests += 1
                                var test = new TestCase(suite, mpropdef, toolcontext)
                                test.before = before
                                test.after = after
                                suite.test_cases.add test
                        end
                end
                # method to execute after all tests in the module
                for mmethod in mmodule.after_all do
                        toolcontext.modelbuilder.total_tests += 1
                        suite.after_all.add new TestCase(suite, mmethod, toolcontext)
                end
                suite.run
                return suite
        end

        # Is the test suite name match the pattern option?
        private fun suite_match_pattern(suite: MClassDef): Bool do
                var pattern = mbuilder.toolcontext.opt_pattern.value
                if pattern == null then return true
                var ps = pattern.split_with("::")
                var p = ps.first
                if ps.length == 1 and p.first.is_lower then return true
                if ps.length == 2 and p.first.is_lower then return false
                if p.has_suffix("*") then
                        p = p.substring(0, p.length - 1)
                        if suite.name.has_prefix(p) then return true
                else
                        if suite.name == p then return true
                end
                return false
        end

        # Is the test case name match the pattern option?
        private fun case_match_pattern(case: MPropDef): Bool do
                var pattern = mbuilder.toolcontext.opt_pattern.value
                if pattern == null then return true
                var ps = pattern.split_with("::")
                var p = ps.last
                if ps.length == 1 and p.first.is_upper then return true
                if ps.length == 2 and p.first.is_upper then return false
                if p.has_suffix("*") then
                        p = p.substring(0, p.length - 1)
                        if case.name.has_prefix(p) then return true
                else
                        if case.name == p then return true
                end
                return false
        end
end

# A test suite contains all the test cases for a `MModule`.
class TestSuite

        # `MModule` under test
        var mmodule: MModule

        # `ToolContext` to use to display messages.
        var toolcontext: ToolContext

        # List of `TestCase` to be executed in this suite.
        var test_cases = new Array[TestCase]

        # Tests to be executed before the whole test suite.
        var before_all = new Array[TestCase]

        # Tests to be executed after the whole test suite.
        var after_all = new Array[TestCase]

        # Display test suite status in std-out.
        fun show_status do
                var test_cases = self.test_cases.to_a
                test_cases.add_all before_all
                test_cases.add_all after_all
                toolcontext.show_unit_status("Test-suite of module " + mmodule.full_name, test_cases)
        end

        # Execute the test suite
        fun run do
                set_env
                show_status
                if not toolcontext.test_dir.file_exists then
                        toolcontext.test_dir.mkdir
                end
                write_to_nit
                compile
                if failure != null then
                        for case in test_cases do
                                case.fail "Compilation Error"
                                case.raw_output = failure
                                toolcontext.clear_progress_bar
                                toolcontext.show_unit(case)
                        end
                        show_status
                        print ""
                        return
                end
                toolcontext.info("Execute test-suite {mmodule.name}", 1)

                for before_module in before_all do
                        before_module.run
                        toolcontext.clear_progress_bar
                        toolcontext.show_unit(before_module)
                        if before_module.error != null then
                                for case in test_cases do
                                        case.fail "Nitunit Error: before_module test failed"
                                        toolcontext.clear_progress_bar
                                        toolcontext.show_unit(case)
                                end
                                for after_module in after_all do
                                        after_module.fail "Nitunit Error: before_module test failed"
                                        toolcontext.clear_progress_bar
                                        toolcontext.show_unit(after_module)
                                end
                                show_status
                                print ""
                                return
                        end
                end

                for case in test_cases do
                        case.run
                        toolcontext.clear_progress_bar
                        toolcontext.show_unit(case)
                        show_status
                end

                for after_module in after_all do
                        after_module.run
                        toolcontext.clear_progress_bar
                        toolcontext.show_unit(after_module)
                        show_status
                end

                show_status
                print ""
        end

        # Write the test unit for `self` in a nit compilable file.
        fun write_to_nit do
                var file = new Template
                file.addn "intrude import core"
                file.addn "import {mmodule.name}\n"
                file.addn "var name = args.first"
                for before_module in before_all do
                        before_module.write_to_nit(file)
                end
                for case in test_cases do
                        case.write_to_nit(file)
                end
                for after_module in after_all do
                        after_module.write_to_nit(file)
                end
                file.write_to_file("{test_file}.nit")
        end

        # Return the test suite in XML format compatible with Jenkins.
        # Contents depends on the `run` execution.
        fun to_xml: HTMLTag do
                var n = new HTMLTag("testsuite")
                n.attr("package", mmodule.name)
                for test in test_cases do n.add test.to_xml
                return n
        end

        # Generated test file name.
        fun test_file: String do
                return toolcontext.test_dir / "gen_{mmodule.name.escape_to_c}"
        end

        # Compile all `test_cases` cases in one file.
        fun compile do
                # find nitc
                var nitc = toolcontext.find_nitc
                # compile test suite
                var file = test_file
                var module_file = mmodule.location.file
                if module_file == null then
                        toolcontext.error(null, "Error: cannot find module file for {mmodule.name}.")
                        toolcontext.check_errors
                        return
                end
                var include_dir = module_file.filename.dirname
                var cmd = "{nitc} --no-color -q '{file}.nit' -I {include_dir} -o '{file}.bin' > '{file}.out' 2>&1 </dev/null"
                var res = toolcontext.safe_exec(cmd)
                var f = new FileReader.open("{file}.out")
                var msg = f.read_all
                f.close
                if res != 0 then
                        failure = msg
                end
        end

        # Set environment variables for test suite execution
        fun set_env do
                var loc = mmodule.location.file
                if loc == null then return
                toolcontext.set_testing_path(loc.filename)
        end

        # Error occured during test-suite compilation.
        var failure: nullable String = null
end

# A test case is a unit test considering only a `MMethodDef`.
class TestCase
        super UnitTest

        # Test suite wich `self` belongs to.
        var test_suite: TestSuite

        # Test method to be compiled and tested.
        var test_method: MMethodDef

        # Cases to execute before this one
        var before = new Array[MMethodDef]

        # Cases to execute after this one
        var after = new Array[MMethodDef]

        redef fun full_name do return test_method.full_name

        redef fun location do return test_method.location

        # `ToolContext` to use to display messages and find `nitc` bin.
        var toolcontext: ToolContext

        # Generate the test unit for `self` in `file`.
        fun write_to_nit(file: Template) do
                var name = test_method.name
                file.addn "if name == \"{name}\" then"
                if test_method.mproperty.is_toplevel then
                        file.addn "\t{name}"
                else
                        file.addn "\tvar subject = new {test_method.mclassdef.name}.intern"
                        for mmethod in before do
                                file.addn "\tsubject.{mmethod.name}"
                        end
                        file.addn "\tsubject.{name}"
                        for mmethod in after do
                                file.addn "\tsubject.{mmethod.name}"
                        end
                end
                file.addn "end"
        end

        # Execute the test case.
        fun run do
                toolcontext.info("Execute test-case {test_method.name}", 1)
                was_exec = true
                if toolcontext.opt_noact.value then return
                # execute
                var method_name = test_method.name
                var test_file = test_suite.test_file
                var res_name = "{test_file}_{method_name.escape_to_c}"
                var clock = new Clock
                var res = toolcontext.safe_exec("{test_file}.bin {method_name} > '{res_name}.out1' 2>&1 </dev/null")
                if not toolcontext.opt_no_time.value then real_time = clock.total

                var raw_output = "{res_name}.out1".to_path.read_all
                self.raw_output = raw_output
                # set test case result
                if res != 0 then
                        error = "Runtime Error in file {test_file}.nit"
                        toolcontext.modelbuilder.failed_tests += 1
                else
                        # no error, check with res file, if any.
                        var mmodule = test_method.mclassdef.mmodule
                        var file = mmodule.filepath
                        if file != null then
                                var tries = [ file.dirname / mmodule.name + ".sav" / test_method.name + ".res",
                                        file.dirname / "sav" / test_method.name + ".res" ,
                                        file.dirname / test_method.name + ".res" ]
                                var savs = [ for t in tries do if t.file_exists then t ]
                                if savs.length == 1 then
                                        var sav = savs.first
                                        toolcontext.info("Diff output with {sav}", 1)
                                        res = toolcontext.safe_exec("diff -u --label 'expected:{sav}' --label 'got:{res_name}.out1' '{sav}' '{res_name}.out1' > '{res_name}.diff' 2>&1 </dev/null")
                                        if res == 0 then
                                                # OK
                                        else if toolcontext.opt_autosav.value then
                                                raw_output.write_to_file(sav)
                                                info = "Expected output updated: {sav} (--autoupdate)"
                                        else
                                                self.raw_output = "Diff\n" + "{res_name}.diff".to_path.read_all
                                                error = "Difference with expected output: diff -u {sav} {res_name}.out1"
                                                toolcontext.modelbuilder.failed_tests += 1
                                        end
                                else if savs.length > 1 then
                                        toolcontext.info("Conflicting diffs: {savs.join(", ")}", 1)
                                        error = "Conflicting expected output: {savs.join(", ", " and ")} all exist"
                                        toolcontext.modelbuilder.failed_tests += 1
                                else if not raw_output.is_empty then
                                        toolcontext.info("No diff: {tries.join(", ", " or ")} not found", 1)
                                        if toolcontext.opt_autosav.value then
                                                var sav = tries.first
                                                sav.dirname.mkdir
                                                raw_output.write_to_file(sav)
                                                info = "Expected output saved: {sav} (--autoupdate)"
                                        end
                                end
                        end
                end
                is_done = true
        end

        # Make the test case fail without testing it
        #
        # Useful when the compilation or the before_test failed.
        fun fail(message: String) do
                is_done = true
                error = message
                toolcontext.modelbuilder.failed_tests += 1
        end

        redef fun xml_classname do
                var a = test_method.full_name.split("$")
                return "nitunit.{a[0]}.{a[1]}"
        end

        redef fun xml_name do
                var a = test_method.full_name.split("$")
                return a[2]
        end
end

redef class MClassDef
        # Methods tagged with `before` in this class definition
        private fun before: Array[MMethodDef] do
                var res = new Array[MMethodDef]
                for mpropdef in mpropdefs do
                        if mpropdef isa MMethodDef and mpropdef.is_before then
                                res.add mpropdef
                        end
                end
                var in_hierarchy = self.in_hierarchy
                if in_hierarchy == null then return res
                for mclassdef in in_hierarchy.direct_greaters do
                        res.add_all mclassdef.before
                end
                return res
        end

        # Methods tagged with `before_all` in this class definition
        private fun before_all: Array[MMethodDef] do
                var res = new Array[MMethodDef]
                for mpropdef in mpropdefs do
                        if mpropdef isa MMethodDef and mpropdef.is_before_all then
                                res.add mpropdef
                        end
                end
                var in_hierarchy = self.in_hierarchy
                if in_hierarchy == null then return res
                for mclassdef in in_hierarchy.direct_greaters do
                        res.add_all mclassdef.before_all
                end
                return res
        end

        # Methods tagged with `after` in this class definition
        private fun after: Array[MMethodDef] do
                var res = new Array[MMethodDef]
                for mpropdef in mpropdefs do
                        if mpropdef isa MMethodDef and mpropdef.is_after then
                                res.add mpropdef
                        end
                end
                var in_hierarchy = self.in_hierarchy
                if in_hierarchy == null then return res
                for mclassdef in in_hierarchy.direct_greaters do
                        res.add_all mclassdef.after
                end
                return res
        end

        # Methods tagged with `after_all` in this class definition
        private fun after_all: Array[MMethodDef] do
                var res = new Array[MMethodDef]
                for mpropdef in mpropdefs do
                        if mpropdef isa MMethodDef and mpropdef.is_after_all then
                                res.add mpropdef
                        end
                end
                var in_hierarchy = self.in_hierarchy
                if in_hierarchy == null then return res
                for mclassdef in in_hierarchy.direct_greaters do
                        res.add_all mclassdef.after_all
                end
                return res
        end
end

redef class MModule
        # Methods tagged with `before_all` at the module level (in `Sys`)
        private fun before_all: Array[MMethodDef] do
                var res = new Array[MMethodDef]
                for mmodule in in_importation.greaters do
                        for mclassdef in mmodule.mclassdefs do
                                if mclassdef.name != "Sys" then continue
                                for mpropdef in mclassdef.mpropdefs do
                                        if not mpropdef isa MMethodDef or not mpropdef.is_before_all then continue
                                        res.add mpropdef
                                end
                        end
                end
                return res
        end

        # Methods tagged with `after_all` at the module level (in `Sys`)
        private fun after_all: Array[MMethodDef] do
                var res = new Array[MMethodDef]
                for mmodule in in_importation.greaters do
                        for mclassdef in mmodule.mclassdefs do
                                if mclassdef.name != "Sys" then continue
                                for mpropdef in mclassdef.mpropdefs do
                                        if not mpropdef isa MMethodDef or not mpropdef.is_after_all then continue
                                        res.add mpropdef
                                end
                        end
                end
                return res
        end
end

redef class ModelBuilder
        # Number of test classes generated.
        var total_classes = 0

        # Number of tests generated.
        var total_tests = 0

        # Number of failed tests.
        var failed_tests = 0

        # Run NitUnit test suite for `mmodule` (if it is one).
        fun test_unit(mmodule: MModule): nullable HTMLTag do
                # is the module a test_suite?
                if not mmodule.is_test then return null
                toolcontext.info("nitunit: test-suite {mmodule}", 2)

                var tester = new NitUnitTester(self)
                var res = tester.test_module_unit(mmodule)
                return res.to_xml
        end
end