vic-buildr 1.3.1 → 1.3.3

data/lib/buildr/java/test_result.rb

@@ -0,0 +1,277 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you 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.
+
+require 'yaml'
+
+module Buildr #:nodoc:
+  module TestFramework
+    
+    # A class used by buildr for jruby based frameworks, so that buildr can know 
+    # which tests succeeded/failed.
+    class TestResult
+
+      class Error < ::Exception
+        attr_reader :message, :backtrace
+        def initialize(message, backtrace)
+          @message = message
+          @backtrace = backtrace
+        end
+
+        def self.dump_yaml(file, e)
+          require 'fileutils'
+          FileUtils.mkdir_p(File.dirname(file))
+          File.open(file, 'w') { |f| f.puts(YAML.dump(Error.new(e.message, e.backtrace))) }
+        end
+
+        def self.guard(file)
+          begin 
+            yield
+          rescue
+            dump_yaml(file)
+          end
+        end
+      end
+      
+      attr_accessor :failed, :succeeded
+
+      def initialize
+        @failed, @succeeded = [], []
+      end
+
+      # An Rspec formatter used by buildr
+      class YamlFormatter
+        attr_reader :result
+
+        attr_accessor :example_group, :options, :where
+        
+        def initialize(options, where)
+          @options = options
+          @where = where
+        end
+        
+        %w[ example_started example_passed example_failed example_pending
+            start_dump dump_failure dump_summary dump_pending ].each do |meth|
+          module_eval "def #{meth}(*args); end"
+        end
+
+        def add_example_group(example_group)
+          @example_group = example_group
+        end
+
+        def start(example_count)
+          @result = TestResult.new
+        end
+
+        def close
+          files = options.files
+          failure_from_bt = lambda do |ary|
+            test = nil
+            ary.find do |bt|
+              bt = bt.split(':').first.strip
+              test = bt if files.include?(bt)
+            end
+            test
+          end
+          options.reporter.instance_variable_get(:@failures).each do |failure|
+            result.failed << files.delete(failure_from_bt[failure.exception.backtrace])
+          end
+          result.succeeded |= files
+          
+          FileUtils.mkdir_p(File.dirname(where))
+          File.open(where, 'w') { |f| f.puts YAML.dump(result) }
+        end
+      end # YamlFormatter
+
+      # A JtestR ResultHandler
+      # Using this handler we can use RSpec formatters, like html/ci_reporter with JtestR
+      # Created for YamlFormatter
+      class RSpecResultHandler
+
+        # Workaround for http://jira.codehaus.org/browse/JTESTR-68
+        module TestNGResultHandlerMixin
+          def onTestSuccess(test_result)
+            @result_handler.succeed_single(test_result.name)
+          end
+        end
+
+        class BacktraceTweaker
+          attr_reader :ignore_patterns
+          def initialize
+            @ignore_patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.dup
+            # ignore jruby/jtestr backtrace
+            ignore_patterns << /org\.jruby\.javasupport\.JavaMethod\./
+            ignore_patterns << /jtestr.*\.jar!/i << /runner\.rb/
+          end
+          
+          def clean_up_double_slashes(line)
+            line.gsub!('//','/')
+          end
+
+          def tweak_backtrace(error)
+            return if error.backtrace.nil?
+            error.backtrace.collect! do |line|
+              clean_up_double_slashes(line)
+              ignore_patterns.each do |ignore|
+                if line =~ ignore
+                  line = nil
+                  break
+                end
+              end
+              line
+            end
+            error.backtrace.compact!
+          end
+        end
+        
+        class << self
+          # an rspec reporter used to proxy events to rspec formatters
+          attr_reader :reporter
+
+          def init(argv = [], out = STDOUT, err = STDERR)
+            ::JtestR::TestNGResultHandler.module_eval { include TestNGResultHandlerMixin }
+            rspec_parser = ::Spec::Runner::OptionParser.new(err, out)
+            rspec_parser.order!(argv)
+            rspec_parser.options.backtrace_tweaker = BacktraceTweaker.new
+            @reporter = Spec::Runner::Reporter.new(rspec_parser.options)
+          end
+
+          def before
+            reporter.start(reporter.options.files.size)
+          end
+
+          def after
+            reporter.end
+            reporter.dump
+          end
+        end
+
+        module ExampleMethods
+          attr_accessor :name, :description, :__full_description
+        end
+
+        def reporter
+          self.class.reporter
+        end
+
+        attr_accessor :example_group, :current_example, :current_failure
+
+        def initialize(name, desc, *args)
+          self.example_group = ::Spec::Example::ExampleGroup.new(desc)
+          example_group.extend ExampleMethods
+          example_group.name = name.to_s
+          if example_group.name[/Spec/]
+            example_group.description = desc.to_s
+          else
+            example_group.description = name.to_s
+          end
+          reporter.add_example_group(example_group)
+        end
+
+        def starting
+        end
+
+        def ending
+        end
+
+        def add_fault(fault)
+          self.current_failure = fault
+        end
+
+        def add_pending(pending)
+        end
+
+        def starting_single(name = nil)
+          self.current_failure = nil
+          self.current_example = Object.new
+          current_example.extend ::Spec::Example::ExampleMethods
+          current_example.extend ExampleMethods
+          name = name.to_s
+          name[/\((pen?ding|error|failure|success)\)?$/]
+          name = $`
+          current_example.description = name
+          if example_group.name[/Spec/]
+            current_example.__full_description = "#{example_group.description} #{name}"
+          else
+            current_example.__full_description = "#{example_group.name}: #{name}"
+          end
+          reporter.example_started(current_example)
+          #puts "STARTED #{name} #{current_example.__full_description}"
+        end
+
+        def succeed_single(name = nil)
+          #puts "SUCC SINGLE #{name}"
+          reporter.example_finished(current_example, nil)
+        end
+        
+        def fail_single(name = nil)
+          #puts "FAIL SINGLE #{name}"
+          reporter.example_finished(current_example, current_error)
+        end
+
+        def error_single(name = nil)
+          #puts "ERR SINGLE #{name}"
+          reporter.example_finished(current_example, current_error)
+        end
+
+        def pending_single(name = nil)
+          #puts "PEND SINGLE #{name}"
+          error = ::Spec::Example::ExamplePendingError.new(name)
+          reporter.example_finished(current_example, error)
+        end
+
+      private
+        def current_error(fault = current_failure)
+          case fault
+          when nil
+            nil
+          when Test::Unit::Failure
+            Error.new(fault.message, fault.location)
+          when Test::Unit::Error, Expectations::Results::Error, Spec::Runner::Reporter::Failure
+            fault.exception
+          when Expectations::Results
+            file = fault.file
+            line = fault.line
+            Error.new(fault.message, ["#{fault.file}:#{fault.line}"])
+          else
+            if fault.respond_to?(:test_header)
+              fault.test_header[/\((.+)\)/]
+              test_cls, test_meth = $1.to_s, $`.to_s
+              exception = fault.exception
+              (class << exception; self; end).module_eval do
+                define_method(:backtrace) do 
+                  (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
+                end
+              end
+              exception
+            elsif fault.respond_to?(:method)
+              test_cls, test_meth = fault.method.test_class.name, fault.method.method_name
+              exception = fault.throwable
+              (class << exception; self; end).module_eval do
+                define_method(:backtrace) do 
+                  (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
+                end
+              end
+              exception
+            else
+              raise "Cannot handle fault #{fault.class}: #{fault.inspect}"
+            end
+          end
+        end
+
+      end # RSpecResultHandler
+
+    end # TestResult
+  end
+end

data/lib/buildr/java/{test_frameworks.rb → tests.rb}

@@ -18,76 +18,89 @@ require 'buildr/core/build'
 require 'buildr/core/compile'
 require 'buildr/java/ant'
 
-module Buildr
 
-  class TestFramework
-    module JavaTest
+module Buildr
 
-      # Add buildr utilities (JavaTestFilter) to classpath
-      Java.classpath << File.join(File.dirname(__FILE__))
+  class TestFramework::Java < TestFramework::Base
 
-      def self.included(mod)
-        super
-        mod.extend ClassMethods
+    class << self
+      
+      def applies_to?(project) #:nodoc:
+        project.test.compile.language == :java
       end
-
-      private
-      # :call-seq:
-      #     filter_classes(dependencies, criteria)
-      # 
-      # Return a list of classnames that match the given criteria. 
-      # The criteria parameter is a hash that must contain at least one of:
-      #
-      # * :class_names -- List of patterns to match against class name
-      # * :interfaces -- List of java interfaces or java classes
-      # * :class_annotations -- List of annotations on class level
-      # * :method_annotations -- List of annotations on method level
-      #
-      def filter_classes(dependencies, criteria = {})
-        return [] unless task.compile.target
-        target = task.compile.target.to_s
-        candidates = Dir["#{target}/**/*.class"].
-          map { |file| Util.relative_path(file, target).ext('').gsub(File::SEPARATOR, '.') }.
-          reject { |name| name =~ /\$/ }
-        result = []
-        if criteria[:class_names]
-          result.concat candidates.select { |name| criteria[:class_names].flatten.any? { |pat| pat === name } }
+      
+    end
+    
+  private
+
+    # Add buildr utilities (JavaTestFilter) to classpath
+    Java.classpath << File.join(File.dirname(__FILE__))
+
+    # :call-seq:
+    #     filter_classes(dependencies, criteria)
+    # 
+    # Return a list of classnames that match the given criteria. 
+    # The criteria parameter is a hash that must contain at least one of:
+    #
+    # * :class_names -- List of patterns to match against class name
+    # * :interfaces -- List of java interfaces or java classes
+    # * :class_annotations -- List of annotations on class level
+    # * :method_annotations -- List of annotations on method level
+    #
+    def filter_classes(dependencies, criteria = {})
+      return [] unless task.compile.target
+      target = task.compile.target.to_s
+      candidates = Dir["#{target}/**/*.class"].
+        map { |file| Util.relative_path(file, target).ext('').gsub(File::SEPARATOR, '.') }.
+        reject { |name| name =~ /\$/ }
+      result = []
+      if criteria[:class_names]
+        result.concat candidates.select { |name| criteria[:class_names].flatten.any? { |pat| pat === name } }
+      end
+      begin
+        Java.load
+        filter = Java.org.apache.buildr.JavaTestFilter.new(dependencies.to_java(Java.java.lang.String))
+        if criteria[:interfaces]
+          filter.add_interfaces(criteria[:interfaces].to_java(Java.java.lang.String)) 
         end
-        begin
-          Java.load
-          filter = Java.org.apache.buildr.JavaTestFilter.new(dependencies.to_java(Java.java.lang.String))
-          if criteria[:interfaces]
-            filter.add_interfaces(criteria[:interfaces].to_java(Java.java.lang.String)) 
-          end
-          if criteria[:class_annotations]
-            filter.add_class_annotations(criteria[:class_annotations].to_java(Java.java.lang.String))
-          end
-          if criteria[:method_annotations]
-            filter.add_method_annotations(criteria[:method_annotations].to_java(Java.java.lang.String))
-          end
-          result.concat filter.filter(candidates.to_java(Java.java.lang.String)).map(&:to_s)
-        rescue =>ex
-          puts "#{ex.class}: #{ex.message}" if verbose
-          raise
+        if criteria[:class_annotations]
+          filter.add_class_annotations(criteria[:class_annotations].to_java(Java.java.lang.String))
         end
-        result.uniq
-      end
-      
-      module ClassMethods
-        def applies_to?(project) #:nodoc:
-          project.test.compile.language == :java
-        end        
+        if criteria[:method_annotations]
+          filter.add_method_annotations(criteria[:method_annotations].to_java(Java.java.lang.String))
+        end
+        result.concat filter.filter(candidates.to_java(Java.java.lang.String)).map(&:to_s)
+      rescue =>ex
+        info "#{ex.class}: #{ex.message}"
+        raise
       end
-      
+      result.uniq
     end
+    
   end
 
+
   # JMock is available when using JUnit and TestNG, JBehave.
   module JMock
-    # JMock version.
-    VERSION = '1.2.0' unless const_defined?('VERSION')
-    # JMock specification.
-    REQUIRES = ["jmock:jmock:jar:#{VERSION}"]
+    
+    VERSION = '1.2.0'
+    
+    class << self
+      def version
+        Buildr.settings.build['jmock'] || VERSION
+      end
+
+      def dependencies
+        @dependencies ||= ["jmock:jmock:jar:#{version}"]
+      end
+      
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use JMock.dependencies/.version instead of JMock::REQUIRES/VERSION"
+        dependencies
+      end
+    end    
   end
 
 
@@ -100,16 +113,13 @@ module Buildr
   # * :properties  -- Hash of system properties available to the test case.
   # * :environment -- Hash of environment variables available to the test case.
   # * :java_args   -- Arguments passed as is to the JVM.
-  class JUnit < TestFramework::Base
+  class JUnit < TestFramework::Java
 
     # 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.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.
@@ -136,6 +146,8 @@ module Buildr
         rm_rf html_in ; mkpath html_in
         
         Buildr.ant('junit-report') do |ant|
+          ant.taskdef :name=>'junitreport', :classname=>'org.apache.tools.ant.taskdefs.optional.junit.XMLResultAggregator',
+            :classpath=>Buildr.artifacts(JUnit.ant_taskdef).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
           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) }.
@@ -151,8 +163,10 @@ module Buildr
 
     end
 
-    class << self
+    # JUnit version number.
+    VERSION = '4.4'
 
+    class << self
       # :call-seq:
       #    report()
       #
@@ -164,18 +178,26 @@ module Buildr
         @report ||= Report.new
       end
 
-    end
-
-    # JUnit version number.
-    VERSION = '4.3.1' unless const_defined?('VERSION')
-    
-    REQUIRES = ["junit:junit:jar:#{VERSION}"] + JMock::REQUIRES
-
-    # Ant-JUnit requires for JUnit and JUnit reports tasks.
-    Java.classpath << "org.apache.ant:ant-junit:jar:#{Ant::VERSION}"
+      def version
+        Buildr.settings.build['junit'] || VERSION
+      end
+      
+      def dependencies
+        @dependencies ||= ["junit:junit:jar:#{version}"]+ JMock.dependencies
+      end
+      
+      def ant_taskdef #:nodoc:
+        "org.apache.ant:ant-junit:jar:#{Ant.version}"
+      end
+      
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use JUnit.dependencies/.version instead of JUnit::REQUIRES/VERSION"
+        dependencies
+      end
+    end          
 
-    include TestFramework::JavaTest
-    
     def tests(dependencies) #:nodoc:
       filter_classes(dependencies, 
                      :interfaces => %w{junit.framework.TestCase},
@@ -197,6 +219,11 @@ module Buildr
           fail 'Option fork must be :once, :each or false.'
         end
         mkpath task.report_to.to_s
+
+        taskdef = Buildr.artifact(JUnit.ant_taskdef)
+        taskdef.invoke
+        ant.taskdef :name=>'junit', :classname=>'org.apache.tools.ant.taskdefs.optional.junit.JUnitTask', :classpath=>taskdef.to_s
+
         ant.junit forking.merge(:clonevm=>options[:clonevm] || false, :dir=>task.send(:project).path_to) do
           ant.classpath :path=>dependencies.join(File::PATH_SEPARATOR)
           (options[:properties] || []).each { |key, value| ant.sysproperty :key=>key, :value=>value }
@@ -231,7 +258,7 @@ module Buildr
       desc "Generate JUnit tests report in #{report.target}"
       task('report') do |task|
         report.generate Project.projects
-        puts "Generated JUnit tests report in #{report.target}" if verbose
+        info "Generated JUnit tests report in #{report.target}"
       end
     end
 
@@ -246,14 +273,26 @@ module Buildr
   # Support the following options:
   # * :properties -- Hash of properties passed to the test suite.
   # * :java_args -- Arguments passed to the JVM.
-  class TestNG < TestFramework::Base
+  class TestNG < TestFramework::Java
 
-    # TestNG version number.
-    VERSION = '5.5' unless const_defined?('VERSION')
-    # TestNG specification.
-    REQUIRES = ["org.testng:testng:jar:jdk15:#{VERSION}"] + JMock::REQUIRES
+    VERSION = '5.7'
 
-    include TestFramework::JavaTest
+    class << self
+      def version
+        Buildr.settings.build['testng'] || VERSION
+      end
+      
+      def dependencies
+        ["org.testng:testng:jar:jdk15:#{version}"]+ JMock.dependencies
+      end  
+      
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use TestNG.dependencies/.version instead of TestNG::REQUIRES/VERSION"
+        dependencies
+      end
+    end          
 
     def tests(dependencies) #:nodoc:
       filter_classes(dependencies, 
@@ -278,14 +317,8 @@ module Buildr
 
   end
 
-end
+end # Buildr
 
 
 Buildr::TestFramework << Buildr::JUnit
 Buildr::TestFramework << Buildr::TestNG
-
-# Backward compatibility crap.
-Buildr::JUnit::JUNIT_REQUIRES = Buildr::JUnit::REQUIRES
-Buildr::TestNG::TestNG_REQUIRES = Buildr::TestNG::REQUIRES
-Java::JUnit = Buildr::JUnit
-Java::TestNG = Buildr::TestNG