buildr 1.3.2-java → 1.3.3-java

data/lib/buildr/java/rjb.rb

@@ -71,9 +71,13 @@ module Java
     end
 
   end
+  
+  # On OS X we know where the default JDK is. We can try to guess for other OS.
+  # We set JAVA_HOME early so we can use it without calling Java.load first.
+  ENV['JAVA_HOME'] ||= '/System/Library/Frameworks/JavaVM.framework/Home' if Config::CONFIG['host_os'] =~ /darwin/i
 
   class << self
-
+    
     # Returns the classpath, an array listing directories, JAR files and
     # artifacts.  Use when loading the extension to add any additional
     # libraries used by that extension.
@@ -83,19 +87,28 @@ module Java
     def classpath
       @classpath ||= []
     end
-
+    
+    # Most platforms requires tools.jar to be on the classpath, tools.jar contains the
+    # Java compiler (OS X and AIX are two exceptions we know about, may be more).
+    # Guess where tools.jar is from JAVA_HOME, which hopefully points to the JDK,
+    # but maybe the JRE.  Return nil if not found.
+    def tools_jar #:nodoc:
+      @tools_jar ||= begin
+        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
+        ['lib/tools.jar', '../lib/tools.jar'].map { |path| File.expand_path(path, home) }.
+          find { |path| File.exist?(path) }
+      end
+    end
+    
     # Loads the JVM and all the libraries listed on the classpath.  Call this
     # method before accessing any Java class, but only call it from methods
     # used in the build, giving the Buildfile a chance to load all extensions
     # that append to the classpath and specify which remote repositories to use.
     def load
       return self if @loaded
-      unless RUBY_PLATFORM =~ /darwin/i
-        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
-        tools = File.expand_path('lib/tools.jar', home)
-        raise "I need tools.jar to compile, can't find it in #{home}/lib" unless File.exist?(tools)
-        classpath << tools
-      end
+      classpath << tools_jar if tools_jar
+      
+      classpath.map! { |path| Proc === path ? path.call : path }
       cp = Buildr.artifacts(classpath).map(&:to_s).each { |path| file(path).invoke }
       java_opts = (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split
       ::Rjb.load cp.join(File::PATH_SEPARATOR), java_opts

data/lib/buildr/java/test_result.rb

@@ -0,0 +1,308 @@
+# 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
+          set_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
+          @result = Hash.new
+          @result[:succeeded] = []
+          @result[:failed] = []
+        end
+        
+        %w[ example_started
+            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 example_passed(example)
+        end
+
+        def example_pending(example, counter, failure)
+        end
+
+        def example_failed(example, counter, failure)
+          if example_group.respond_to?(:spec_path)
+            result.failed << example_group.spec_path.gsub(/:\d+$/, '')
+          else
+            path = path_from_bt(failure.exception.backtrace)
+            result.failed << path if path
+          end
+        end
+
+        def start(example_count)
+          @result = TestResult.new
+        end
+
+        def path_from_bt(ary)
+          files = options.files
+          test = nil
+          ary.find do |bt|
+            bt = bt.split(':').first.strip
+            test = bt if files.include?(bt)
+          end
+          test
+        end
+
+        def close
+          files = options.files
+          result.succeeded = files - result.failed
+          
+          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
+            if fault.exception.is_a?(NativeException)
+              exception = fault.exception.cause
+              bt = exception.stack_trace.to_a
+            else
+              exception = fault.exception
+              bt = exception.backtrace
+            end
+            Error.new(exception.message, bt)
+          when Expectations::Results::Error
+            fault.exception
+          when Spec::Runner::Reporter::Failure
+            ex = fault.exception
+            fault.example.instance_variable_get(:@_implementation).to_s =~ /@(.+:\d+)/
+            Error.new(ex.message, [$1.to_s] + ex.backtrace)
+          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/tests.rb

@@ -0,0 +1,324 @@
+# 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 'buildr/core/build'
+require 'buildr/core/compile'
+require 'buildr/java/ant'
+
+
+module Buildr
+
+  class TestFramework::Java < TestFramework::Base
+
+    class << self
+      
+      def applies_to?(project) #:nodoc:
+        project.test.compile.language == :java
+      end
+      
+    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
+        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
+        info "#{ex.class}: #{ex.message}"
+        raise
+      end
+      result.uniq
+    end
+    
+  end
+
+
+  # JMock is available when using JUnit and TestNG, JBehave.
+  module JMock
+    
+    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
+
+
+  # JUnit test framework, the default test framework for Java tests.
+  #
+  # Support the following options:
+  # * :fork        -- If true/:once (default), fork for each test class.  If :each, fork for each individual
+  #                   test case.  If false, run all tests in the same VM (fast, but dangerous).
+  # * :clonevm     -- If true clone the VM each time it is forked.
+  # * :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::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
+
+      # 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.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) }.
+              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.
+    VERSION = '4.4'
+
+    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 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          
+
+    def tests(dependencies) #:nodoc:
+      filter_classes(dependencies, 
+                     :interfaces => %w{junit.framework.TestCase},
+                     :class_annotations => %w{org.junit.runner.RunWith},
+                     :method_annotations => %w{org.junit.Test})
+    end
+
+    def run(tests, dependencies) #:nodoc:
+      # 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
+        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 }
+          (options[:environment] || []).each { |key, value| ant.env :key=>key, :value=>value }
+          Array(options[:java_args]).each { |value| ant.jvmarg :value=>value }
+          ant.formatter :type=>'plain'
+          ant.formatter :type=>'plain', :usefile=>false # log test
+          ant.formatter :type=>'xml'
+          ant.batchtest :todir=>task.report_to.to_s, :failureproperty=>'failed' do
+            ant.fileset :dir=>task.compile.target.to_s do
+              tests.each { |test| ant.include :name=>File.join(*test.split('.')).ext('class') }
+            end
+          end
+        end
+        return tests unless ant.project.getProperty('failed')
+      end
+      # But Ant doesn't tell us what went kaput, so we'll have to parse the test files.
+      tests.inject([]) do |passed, test|
+        report_file = File.join(task.report_to.to_s, "TEST-#{test}.txt")
+        if File.exist?(report_file)
+          report = File.read(report_file)
+          # 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 }
+          passed << test if status[:failures] == 0 && status[:errors] == 0
+        end
+        passed
+      end
+    end
+
+    namespace 'junit' do
+      desc "Generate JUnit tests report in #{report.target}"
+      task('report') do |task|
+        report.generate Project.projects
+        info "Generated JUnit tests report in #{report.target}"
+      end
+    end
+
+    task('clean') { rm_rf report.target.to_s }
+
+  end
+
+
+  # TestNG test framework.  To use in your project:
+  #   test.using :testng
+  #
+  # Support the following options:
+  # * :properties -- Hash of properties passed to the test suite.
+  # * :java_args -- Arguments passed to the JVM.
+  class TestNG < TestFramework::Java
+
+    VERSION = '5.7'
+
+    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, 
+                     :class_annotations => %w{org.testng.annotations.Test},
+                     :method_annotations => %w{org.testng.annotations.Test})
+    end
+
+    def run(tests, dependencies) #:nodoc:
+      cmd_args = [ 'org.testng.TestNG', '-sourcedir', task.compile.sources.join(';'), '-suitename', task.send(:project).name ]
+      cmd_args << '-d' << task.report_to.to_s
+      cmd_options = { :properties=>options[:properties], :java_args=>options[:java_args],
+                      :classpath=>dependencies }
+      tests.inject([]) do |passed, test|
+        begin
+          Java::Commands.java cmd_args, '-testclass', test, cmd_options.merge(:name=>test)
+          passed << test
+        rescue
+          passed
+        end
+      end
+    end
+
+  end
+
+end # Buildr
+
+
+Buildr::TestFramework << Buildr::JUnit
+Buildr::TestFramework << Buildr::TestNG