require "core/build"
require "java/compile"
require "java/ant"
require "core/help"


module Buildr
  module Java

    # *Deprecated:* Use the test task directly instead of calling test.junit.
    class JUnitTask < Rake::Task #:nodoc:

      # The classpath used for running the tests. Includes the compile classpath,
      # compiled classes (target). For everything else, add by calling #with.
      attr_accessor :classpath

      def initialize(*args) #:nodoc:
        super
        @parent = Rake::Task["#{name.split(":")[0...-1].join(":")}"]
      end

      # :call-seq:
      #   include(*classes) => self
      #
      # Include only the specified test cases. Unless specified, the default is to include
      # all test cases. This method accepts multiple arguments and returns self.
      #
      # Test cases are specified using the fully qualified class name. You can also use file-like
      # patterns (glob) to specify collection of classes. For example:
      #   test.include "com.example.FirstTest"
      #   test.include "com.example.*"
      #   test.include "com.example.Module*"
      #   test.include "*.{First,Second}Test"
      #
      # By default, all classes that have a name ending with Test or Suite are included.
      # Use these suffixes for your test and test suite classes respectively, to distinguish them
      # from stubs, helper classes, etc. 
      def include(*classes)
        @parent.include *classes
        self
      end

      # :call-seq:
      #   exclude(*classes) => self
      #
      # Exclude the specified test cases. This method accepts multiple arguments and returns self.
      # See #include for the type of arguments you can use.
      def exclude(*classes)
        @parent.exclude *classes
        self
      end

      # :call-seq:
      #   from(*paths) => self
      #
      # Specify one or more directories that include test cases. 
      def from(*files)
        self
      end

      # :call-seq:
      #   with(*specs) => self
      #
      # Specify artifacts (specs, tasks, files, etc) to include in the classpath when running
      # the test cases.
      def with(*files)
        (@parent.options[:classpath] ||= []).concat files.flatten
        self
      end

      # Returns the JUnit options.
      def options()
        @parent.options
      end

      # :call-seq:
      #   using(options) => self
      #
      # Sets the JUnit options from a hash and returns self. Right now supports passing :properties to JUnit,
      # and :java_args to the JVM.
      #
      # For example:
      #   test.junit.using :properties=>{ "root"=>base_dir }
      def using(options)
        @parent.using options
        self
      end

    end


    # The test task controls the entire test lifecycle.
    #
    # You can use the test task in three ways. You can access and configure specific test tasks,
    # e.g. enhance the #compile task, or run code during #setup/#teardown.
    #
    # You can use convenient methods that handle the most common settings. For example, add classpath
    # dependencies using #with, or include only specific test cases using #include.
    #
    # You can also enhance this task directly. This task will first execute the #compile task, followed
    # by the #setup task, run the unit tests, any other enhancements, and end by executing #teardown.
    #
    # Unit tests are fun from classed compiled by the test.compile class that match the TEST_FILE_PATTERN
    # (i.e. MyClassTest, MyClassTestSuite, etc). The test framework is determined by setting one of the
    # test framework options to true, for example:
    #   test.unsing :testng
    class TestTask < Rake::Task

      class << self

        # Used by the local test and integration tasks to
        # a) Find the local project(s),
        # b) Find all its sub-projects and narrow down to those that have either unit or integration tests,
        # c) Run all the (either unit or integration) tests, and
        # d) Ignore failure if necessary.
        def run_local_tests(integration) #:nodoc:
          Project.local_projects do |project|
            # !(foo ^ bar) tests for equality and accepts nil as false (and select is less obfuscated than reject on ^).
            projects = ([project] + project.projects).select { |project| !(project.test.options[:integration] ^ integration) }
            projects.each do |project|
              puts "Testing #{project.name}" if verbose
              begin
                project.test.invoke
              rescue
                raise unless Buildr.options.test == :all
              end
            end
          end
        end

        # Used by the test/integration rule to only run tests that match the specified names.
        def only_run(tests) #:nodoc:
          tests = tests.map { |name| name =~ /\*/ ? name : "*#{name}*" }
          # Since the test case may reside in a sub-project, we need to set the include/exclude pattern on
          # all sub-projects, but only invoke test on the local project.
          Project.projects.each { |project| project.test.instance_eval { @include = tests ; @exclude.clear } }
        end
      end

      # List of supported test framework, first one being a default. Test frameworks are added by
      # including them in TestTask (e.g. JUnit, TestNG).
      TEST_FRAMEWORKS = []

      # Default options already set on each test task.
      DEFAULT_OPTIONS = { :fail_on_failure=>true, :fork=>:once, :properties=>{}, :environment=>{} }

      # JMock version..
      JMOCK_VERSION = "1.2.0"
      # JMock specification.
      JMOCK_REQUIRES = "jmock:jmock:jar:#{JMOCK_VERSION}"

      # The classpath used for running the tests. Includes the compiled classes (compile.target) and
      # their classpath dependencies. Will also include anything you pass to #with, shared between the
      # testing compile and run classpath dependencies.
      attr_reader :classpath

      def initialize(*args) #:nodoc:
        super
        @classpath = []
        @include = []
        @exclude = []
        parent = Project.task_in_parent_project(name)
        @options = parent && parent.respond_to?(:options) ? parent.options.clone : DEFAULT_OPTIONS.clone
        enhance { run_tests }
      end

      def execute() #:nodoc:
        setup.invoke
        begin
          super
          @project.task("test:junit").invoke # In case someone enhanced it
        rescue RuntimeError
          raise if options[:fail_on_failure]
        ensure
          teardown.invoke
        end
      end

      # *Deprecated* Add a prerequisite to the compile task instead.
      def prepare(*prereqs, &block)
        warn_deprecated "Add a prerequisite to the compile task instead of using the prepare task."
        @project.task("test:prepare").enhance prereqs, &block
      end

      # :call-seq:
      #   compile(*sources) => CompileTask
      #   compile(*sources) { |task| .. } => CompileTask
      #
      # The compile task is similar to the Project's compile task. However, it compiles all
      # files found in the src/java/test directory into the target/test-classes directory.
      # This task is executed by the test task before running any test cases.
      #
      # Once the project definition is complete, all classpath dependencies from the regular
      # compile task are copied over, so you only need to specify classpath dependencies
      # specific to your test cases. You can do so by calling #with on the test task.
      # The classpath dependencies used here are also copied over to the junit task.
      def compile(*sources, &block)
        @project.task("test:compile").from(sources).enhance &block
      end
   
      # :call-seq:
      #   resources(*prereqs) => ResourcesTask
      #   resources(*prereqs) { |task| .. } => ResourcesTask
      #
      # Executes by the #compile task to copy resource files over. See Project#resources.
      def resources(*prereqs, &block)
        @project.task("test:resources").enhance prereqs, &block
      end

      # *Deprecated* Use the test task directly instead of calling test.junit.
      def junit()
        warn_deprecated "Use the test task directly instead of calling test.junit."
        @project.task("test:junit")
      end

      # :call-seq:
      #   setup(*prereqs) => task
      #   setup(*prereqs) { |task| .. } => task
      #
      # Returns the setup task. The setup task is executed at the beginning of the test task,
      # after compiling the test files.
      def setup(*prereqs, &block)
        @project.task("test:setup").enhance prereqs, &block
      end

      # :call-seq:
      #   teardown(*prereqs) => task
      #   teardown(*prereqs) { |task| .. } => task
      #
      # Returns the teardown task. The teardown task is executed at the end of the test task.
      def teardown(*prereqs, &block)
        @project.task("test:teardown").enhance prereqs, &block
      end

      # :call-seq:
      #   with(*specs) => self
      #
      # Specify artifacts (specs, tasks, files, etc) to include in the classpath when compiling
      # and running test cases.
      def with(*artifacts)
        @classpath |= Buildr.artifacts(artifacts.flatten).uniq
        compile.with artifacts
        self
      end

      # Returns various test options.
      attr_reader :options

      # :call-seq:
      #   using(options) => self
      #
      # Sets various test options and returns self. Accepts a hash of options, or symbols (a symbol sets that
      # option to true). For example:
      #   test.using :testng, :fork=>:each, :properties=>{ "url"=>"http://localhost:8080" }
      #
      # Currently supports the following options:
      # * :fail_on_failure -- True to fail on test failure (default is true).
      # * :fork -- Fork test cases (JUnit only).
      # * :java_args -- Java arguments when forking a new JVM.
      # * :properties -- System properties.
      # * :environment -- Environment variables.
      #
      # The :fork option takes the following values:
      # * :once -- Fork one JVM for each project (default).
      # * :each -- Fork one JVM for each test case.
      # * false -- Do not fork, running all test cases in the same JVM.
      def using(*args)
        args.pop.each { |key, value| options[key.to_sym] = value } if Hash === args.last
        args.each { |key| options[key.to_sym] = true }
        self
      end

      # :call-seq:
      #   include(*classes) => self
      #
      # Include only the specified test cases. Unless specified, the default is to include
      # all test cases. This method accepts multiple arguments and returns self.
      #
      # Test cases are specified using the fully qualified class name. You can also use file-like
      # patterns (glob) to specify collection of classes. For example:
      #   test.include "com.example.FirstTest"
      #   test.include "com.example.*"
      #   test.include "com.example.Module*"
      #   test.include "*.{First,Second}Test"
      #
      # By default, all classes that have a name ending with Test or Suite are included.
      # Use these suffixes for your test and test suite classes respectively, to distinguish them
      # from stubs, helper classes, etc. 
      def include(*classes)
        @include += classes
        self
      end

      # :call-seq:
      #   exclude(*classes) => self
      #
      # Exclude the specified test cases. This method accepts multiple arguments and returns self.
      # See #include for the type of arguments you can use.
      def exclude(*classes)
        @exclude += classes
        self
      end

      # :call-seq:
      #    classes() => strings
      #
      # List of test classes to run. Determined by finding all the test classes in the target directory,
      # and reducing based on the include/exclude patterns.
      def classes()
        base = Pathname.new(compile.target.to_s)
        patterns = self.class.const_get("#{framework.to_s.upcase}_TESTS_PATTERN").to_a
        FileList[patterns.map { |pattern| "#{base}/**/#{pattern}.class" }].
          map { |file| Pathname.new(file).relative_path_from(base).to_s.ext("").gsub(File::SEPARATOR, ".") }.
          select { |name| include?(name) }.reject { |name| name =~ /\$/ }.sort
      end

      # List of failed test classes. Set after running the tests.
      attr_reader :failed_tests

      # :call-seq:
      #   include?(name) => boolean
      #
      # Returns true if the specified class name matches the inclusion/exclusion pattern. Used to determine
      # which tests to execute.
      def include?(name)
        (@include.empty? || @include.any? { |pattern| File.fnmatch(pattern, name) }) &&
          !@exclude.any? { |pattern| File.fnmatch(pattern, name) }
      end

      # :call-seq:
      #   requires() => classpath
      #
      # Returns the classpath for the selected test frameworks. Necessary for compiling and running test cases.
      def requires()
        self.class.const_get("#{framework.to_s.upcase}_REQUIRES").to_a + [JMOCK_REQUIRES]
      end

      # :call-seq:
      #   framework() => symbol
      #
      # Returns the test framework, e.g. :junit, :testng.
      def framework()
        @framework ||= TEST_FRAMEWORKS.detect { |name| options[name] } || TEST_FRAMEWORKS.first
      end

      # :call-seq:
      #   report_to() => file
      #
      # Test frameworks that can produce reports, will write them to this directory.
      #
      # This is framework dependent, so unless you use the default test framework, call this method
      # after setting the test framework.
      def report_to()
        @report_to ||= file(@project.path_to(:reports, "#{framework}")=>self)
      end

    protected

      # :call-seq:
      #   run_tests()
      #
      # Runs the test cases using the selected test framework. Executes as part of the task.
      def run_tests()
        classes = self.classes
        if classes.empty?
          @failed_tests = []
        else
          puts "Running tests in #{@project.name}" if verbose
          @failed_tests = send("#{framework}_run",
            :classes    => classes,
            :classpath  => @classpath + [compile.target],
            :properties => { 'baseDir' => compile.target.to_s }.merge(options[:properties] || {}),
            :environment=> options[:environment] || {},
            :java_args  => options[:java_args] || Buildr.options.java_args)
          unless @failed_tests.empty?
            warn "The following tests failed:\n#{@failed_tests.join("\n")}" if verbose
            fail "Tests failed!"
          end
        end
      end

    end


    # The JUnit test framework. This is the default test framework, but you can force it by
    # adding the following to your project:
    #   test.using :testng
    #
    # You can use the report method to control the junit:report task.
    module JUnit

      # Used by the junit:report task. Access through JUnit#report if you want to set various
      # options for that task, for example:
      #   JUnit.report.frames = false
      class Report

        # Ant-Trax required for running the JUnitReport task.
        Java.wrapper.setup { |jw| jw.classpath << "org.apache.ant:ant-trax:jar:#{Ant::VERSION}" }

        # Parameters passed to the Ant JUnitReport task.
        attr_reader :params
        # True (default) to produce a report using frames, false to produce a single-page report.
        attr_accessor :frames
        # Directory for the report style (defaults to using the internal style).
        attr_accessor :style_dir
        # Target directory for generated report.
        attr_accessor :target

        def initialize()
          @params = {}
          @frames = true
          @target = "reports/junit"
        end

        # :call-seq:
        #   generate(projects, target?)
        #
        # Generates a JUnit report for these projects (must run JUnit tests first) into the
        # target directory. You can specify a target, or let it pick the default one from the
        # target attribute.
        def generate(projects, target = @target.to_s)
          html_in = File.join(target, "html")
          rm_rf html_in ; mkpath html_in
          
          Buildr.ant("junit-report") do |ant|
            ant.junitreport :todir=>target do
              projects.select { |project| project.test.framework == :junit }.
                map { |project| project.test.report_to.to_s }.select { |path| File.exist?(path) }.
                each { |path| ant.fileset(:dir=>path) { ant.include :name=>"TEST-*.xml" }  }
              options = { :format=>frames ? "frames" : "noframes" }
              options[:styledir] = style_dir if style_dir
              ant.report options.merge(:todir=>html_in) do
                params.each { |key, value| ant.param :name=>key, :expression=>value }
              end
            end
          end
        end

      end

      # JUnit version number.
      JUNIT_VERSION = "4.3.1"
      # JUnit specification.
      JUNIT_REQUIRES = "junit:junit:jar:#{JUNIT_VERSION}"
      # Pattern for selecting JUnit test classes. Regardless of include/exclude patterns, only classes
      # that match this pattern are used.
      JUNIT_TESTS_PATTERN = [ "Test*", "*Test" ]

      # Ant-JUnit requires for JUnit and JUnit reports tasks.
      Java.wrapper.setup { |jw| jw.classpath << "org.apache.ant:ant-junit:jar:#{Ant::VERSION}" }

      class << self

        # :call-seq:
        #    report()
        #
        # Returns the Report object used by the junit:report task. You can use this object to set
        # various options that affect your report, for example:
        #   JUnit.report.frames = false
        #   JUnit.report.params["title"] = "My App"
        def report()
          @report ||= Report.new
        end

        def included(mod)
          mod::TEST_FRAMEWORKS << :junit
        end
        private :included

      end

    private

      def junit_run(args)
        rm_rf report_to.to_s ; mkpath report_to.to_s
        # Use Ant to execute the Junit tasks, gives us performance and reporting.
        Buildr.ant("junit") do |ant|
          case options[:fork]
          when false
            forking = {}
          when :each
            forking = { :fork=>true, :forkmode=>"perTest" }
          when true, :once
            forking = { :fork=>true, :forkmode=>"once" }
          else
            fail "Option fork must be :once, :each or false."
          end
          ant.junit forking.merge(:clonevm=>options[:clonevm] || false, :dir=>@project.path_to) do
            ant.classpath :path=>args[:classpath].map(&:to_s).each { |path| file(path).invoke }.join(File::PATH_SEPARATOR)
            args[:properties].each { |key, value| ant.sysproperty :key=>key, :value=>value }
            args[:environment].each { |key, value| ant.env :key=>key, :value=>value }
            java_args = args[:java_args]
            java_args = java_args.split(" ") if String === java_args
            java_args.each { |value| ant.jvmarg :value=>value } if java_args
            ant.formatter :type=>"plain"
            ant.formatter :type=>"xml"
            ant.formatter :type=>"plain", :usefile=>false # log test
            ant.formatter :type=>"xml"
            ant.batchtest :todir=>report_to.to_s, :failureproperty=>"failed" do
              ant.fileset :dir=>compile.target.to_s do
                args[:classes].each { |cls| ant.include :name=>cls.gsub(".", "/").ext("class") }
              end
            end
          end
          return [] unless ant.project.getProperty("failed")
        end
        # But Ant doesn't tell us what went kaput, so we'll have to parse the test files.
        args[:classes].inject([]) do |failed, name|
          if report = File.read(File.join(report_to.to_s, "TEST-#{name}.txt")) rescue nil
            # The second line (if exists) is the status line and we scan it for its values.
            status = (report.split("\n")[1] || "").scan(/(run|failures|errors):\s*(\d+)/i).
              inject(Hash.new(0)) { |hash, pair| hash[pair[0].downcase.to_sym] = pair[1].to_i ; hash }
            failed << name if status[:failures] > 0 || status[:errors] > 0
          end
          failed
        end
      end

      namespace "junit" do
        desc "Generate JUnit tests report in #{report.target}"
        task("report") do |task|
          report.generate Project.projects
          puts "Generated JUnit tests report in #{report.target}"
        end
      end

      task("clean") { rm_rf report.target.to_s }

    end


    # The TestNG test framework. Use by adding the following to your project:
    #   test.using :testng
    module TestNG

      # TestNG version number.
      TESTNG_VERSION = "5.5"
      # TestNG specification.
      TESTNG_REQUIRES = "org.testng:testng:jar:jdk15:#{TESTNG_VERSION}"
      # Pattern for selecting TestNG test classes. Regardless of include/exclude patterns, only classes
      # that match this pattern are used.
      TESTNG_TESTS_PATTERN = [ "Test*", "*Test", "*TestCase" ]

      class << self

        def included(mod)
          mod::TEST_FRAMEWORKS << :testng
        end
        private :included

      end

    private

      def testng_run(args)
        cmd_args = [ "org.testng.TestNG", "-sourcedir", compile.sources.join(";"), "-suitename", @project.name ]
        cmd_args << "-d" << report_to.to_s
        cmd_options = args.only(:classpath, :properties, :java_args)
        args[:classes].inject([]) do |failed, test|
          begin
            Buildr.java cmd_args, "-testclass", test, cmd_options.merge(:name=>test)
            failed
          rescue
            failed << test
          end
        end
      end

    end

    class TestTask ; include JUnit ; include TestNG ; end

  end


  class Project

    # :call-seq:
    #   test(*prereqs) => TestTask
    #   test(*prereqs) { |task| .. } => TestTask
    #
    # Returns the test task. The test task controls the entire test lifecycle.
    #
    # You can use the test task in three ways. You can access and configure specific
    # test tasks, e.g. enhance the compile task by calling test.compile, setup for
    # the test cases by enhancing test.setup and so forth.
    #
    # You can use convenient methods that handle the most common settings. For example,
    # add classpath dependencies using test.with, or include only specific test cases
    # using test.include.
    #
    # You can also enhance this task directly. This method accepts a list of arguments
    # that are used as prerequisites and an optional block that will be executed by the
    # test task.
    #
    # This task compiles the project and the test cases (in that order) before running any tests.
    # It execute the setup task, runs all the test cases, any enhancements, and ends with the
    # teardown tasks.
    def test(*prereqs, &block)
      task("test").enhance prereqs, &block
    end
  
  end
      

  Project.on_define do |project|
    # Define a recursive test task, and pass it a reference to the project so it can discover all other tasks.
    Java::TestTask.define_task("test")
    project.test.instance_eval { instance_variable_set :@project, project }
    #project.recursive_task("test")
    # Similar to the regular resources task but using different paths.
    resources = Java::ResourcesTask.define_task("test:resources")
    project.path_to("src/test/resources").tap { |dir| resources.from dir if File.exist?(dir) }
    # Similar to the regular compile task but using different paths.
    compile = Java::CompileTask.define_task("test:compile"=>[project.compile, task("test:prepare"), project.test.resources])
    project.path_to("src/test/java").tap { |dir| compile.from dir if File.exist?(dir) }
    compile.into project.path_to(:target, "test-classes")
    resources.filter.into compile.target
    project.test.enhance [compile]
    # Define the JUnit task here, otherwise we get a normal task.
    Java::JUnitTask.define_task("test:junit")
    # Define these tasks once, otherwise we may get a namespace error.
    project.test.setup ; project.test.teardown

    project.enhance do |project|
      # Copy the regular compile classpath over, and also include the generated classes, both of which
      # can be used in the test cases. And don't forget the classpath required by the test framework (e.g. JUnit).
      project.test.with project.compile.classpath, project.compile.target, project.test.requires
      project.clean do
        verbose(false) do
          rm_rf project.test.compile.target.to_s
          rm_rf project.test.report_to.to_s
        end
      end
    end
  end


  class Options

    # Runs test cases after the build when true (default). This forces test cases to execute
    # after the build, including when running build related tasks like install, deploy and release.
    #
    # Set to false to not run any test cases. Set to :all to run all test cases, ignoring failures.
    #
    # This option is set from the environment variable "test", so you can also do:

    # Returns the test option (environment variable TEST). Possible values are:
    # * :false -- Do not run any test cases (also accepts "no" and "skip").
    # * :true -- Run all test cases, stop on failure (default if not set).
    # * :all -- Run all test cases, ignore failures.
    def test()
      case value = ENV["TEST"] || ENV["test"]
      when /^(no|off|false|skip)$/i
        false
      when /^all$/i
        :all
      when /^(yes|on|true)$/i, nil
        true
      else
        warn "Expecting the environment variable test to be 'no' or 'all', not sure what to do with #{value}, so I'm just going to run all the test cases and stop at failure."
        true
      end
    end

    # Sets the test option (environment variable TEST). Possible values are true, false or :all.
    #
    # You can also set this from the environment variable, e.g.:
    #
    #   buildr          # With tests
    #   buildr test=no  # Without tests
    #   buildr test=all # Ignore failures
    #   set TEST=no
    #   buildr          # Without tests
    def test=(flag)
      ENV["test"] = nil
      ENV["TEST"] = flag.to_s
    end

  end


  desc "Run all test cases"
  task("test") { TestTask.run_local_tests false }

  # This rule takes a suffix and runs that test case in the current project. For example;
  #   buildr test:MyTest
  # will run the test case class com.example.MyTest, if found in the current project.
  #
  # If you want to run multiple test cases, separate tham with a comma. You can also use glob
  # (* and ?) patterns to match multiple tests, e.g. com.example.* to run all test cases in
  # a given package. If you don't specify a glob pattern, asterisks are added for you.
  rule /^test:.*$/ do |task|
    TestTask.only_run task.name.scan(/test:(.*)/)[0][0].split(",")
    task("test").invoke
  end

  task "build" do |task|
    # Make sure this happens as the last action on the build, so all other enhancements
    # are made to run before starting the test cases.
    task.enhance do
      task("test").invoke unless Buildr.options.test == false
    end
  end


  # The integration tests task. Buildr has one such task (see Buildr#integration) that runs
  # all tests marked with :integration=>true, and has a setup/teardown tasks separate from
  # the unit tests.
  class IntegrationTestsTask < Rake::Task

    def initialize(*args) #:nodoc:
      super
      task "#{name}-setup"
      task "#{name}-teardown"
      enhance { puts "Running integration tests..."  if verbose }
    end

    def execute() #:nodoc:
      setup.invoke
      begin
        super
      ensure
        teardown.invoke
      end
    end

    # :call-seq:
    #   setup(*prereqs) => task
    #   setup(*prereqs) { |task| .. } => task
    #
    # Returns the setup task. The setup task is executed before running the integration tests.
    def setup(*prereqs, &block)
      Rake::Task["rake:integration-setup"].enhance prereqs, &block
    end

    # :call-seq:
    #   teardown(*prereqs) => task
    #   teardown(*prereqs) { |task| .. } => task
    #
    # Returns the teardown task. The teardown task is executed after running the integration tests.
    def teardown(*prereqs, &block)
      Rake::Task["rake:integration-teardown"].enhance prereqs, &block
    end

  end

  # :call-seq:
  #   integration() { |task| .... }
  #   integration() => IntegrationTestTask
  #
  # Use this method to return the integration tests task, or enhance it with a block to execute.
  #
  # There is one integration tests task you can execute directly, or as a result of running the package
  # task (or tasks that depend on it, like install and deploy). It contains all the tests marked with
  # :integration=>true, all other tests are considered unit tests and run by the test task before packaging.
  # So essentially: build=>test=>packaging=>integration=>install/deploy.
  #
  # You add new test cases from projects that define integration tests using the regular test task,
  # but with the following addition:
  #   test.using :integration
  #
  # Use this method to enhance the setup and teardown tasks that are executed before (and after) all
  # integration tests are run, for example, to start a Web server or create a database.
  def integration(*deps, &block)
    Rake::Task["rake:integration"].enhance deps, &block
  end

  IntegrationTestsTask.define_task("integration") { TestTask.run_local_tests true }

  # Similar to test:[pattern] but for integration tests.
  rule /^integration:.*$/ do |task|
    TestTask.only_run task.name.scan(/integration:(.*)/)[0][0].split(",")
    task("integration").invoke
  end

  # Anything that comes after local packaging (install, deploy) executes the integration tests,
  # which do not conflict with integration invoking the project's own packaging (package=>
  # integration=>foo:package is not circular, just confusing to debug.)
  task "package" do |task|
    integration.invoke if Buildr.options.test && Rake.application.original_dir == Dir.pwd
  end


  task("help") do
    puts
    puts "To run a full build without running any test cases:"
    puts "  buildr test=no"
    puts "To run specific test case:"
    puts "  buildr test:MyTest"
    puts "To run integration tests:"
    puts "  buildr integration"
  end

end