buildr-gemjar 1.0.0

data/vendor/buildr/spec/java/ant_spec.rb

@@ -0,0 +1,37 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+
+describe Buildr::Ant do
+
+  it 'should pick Ant version from ant build settings' do
+    begin
+      Buildr::Ant.instance_eval { @dependencies = nil }
+      write 'build.yaml', 'ant: 1.2.3'
+      Buildr::Ant.dependencies.should include("org.apache.ant:ant:jar:1.2.3")
+    ensure
+      Buildr::Ant.instance_eval { @dependencies = nil }
+    end
+  end
+
+  it 'should have REQUIRES up to version 1.5 since it was deprecated in version 1.3.3' do
+    Buildr::VERSION.should < '1.5'
+    lambda { Ant::REQUIRES }.should_not raise_error
+  end
+
+end

data/vendor/buildr/spec/java/bdd_spec.rb

@@ -0,0 +1,374 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+describe Buildr::RSpec do
+
+  before(:each) do
+    define('foo') do
+      test.using :rspec, :output => false
+    end
+  end
+
+  it 'should be selected by :rspec name' do
+    project('foo').test.framework.should eql(:rspec)
+  end
+
+  it 'should read passed specs from result yaml' do
+    write('src/spec/ruby/success_spec.rb', 'describe("success") { it("is true") { nil.should be_nil } }')
+
+    project('foo').test.invoke
+    project('foo').test.passed_tests.should eql([File.expand_path('src/spec/ruby/success_spec.rb')])
+  end
+
+  it 'should read result yaml to obtain the list of failed specs' do
+    success = File.expand_path('src/spec/ruby/success_spec.rb')
+    write(success, 'describe("success") { it("is true") { nil.should be_nil } }')
+    failure = File.expand_path('src/spec/ruby/failure_spec.rb')
+    write(failure, 'describe("failure") { it("is false") { true.should == false } }')
+    error = File.expand_path('src/spec/ruby/error_spec.rb')
+    write(error, 'describe("error") { it("raises") { lambda; } }')
+
+    lambda { project('foo').test.invoke }.should raise_error(/Tests failed/)
+    project('foo').test.tests.should include(success, failure, error)
+    project('foo').test.failed_tests.sort.should eql([failure, error].sort)
+    project('foo').test.passed_tests.should eql([success])
+
+  end
+
+end if RUBY_PLATFORM =~ /java/ || ENV['JRUBY_HOME'] # RSpec
+
+describe Buildr::JtestR do
+
+  before do
+    # clear cached dependencies
+    Buildr::JUnit.instance_eval { @dependencies = nil }
+    Buildr::JtestR.instance_eval { @dependencies = nil }
+  end
+
+  def foo(*args, &prc)
+    define('foo', *args) do
+      test.using :jtestr, :output => false
+      if prc
+        instance_eval(&prc)
+      else
+        self
+      end
+    end
+  end
+
+  it 'should be selected by :jtestr name' do
+    foo { test.framework.should eql(:jtestr) }
+  end
+
+  it 'should apply to projects having test_unit sources' do
+    define('one', :base_dir => 'one') do
+      write _('src/spec/ruby/one_test.rb')
+      JtestR.applies_to?(self).should be_true
+    end
+    define('two', :base_dir => 'two') do
+      write _('src/spec/ruby/twoTest.rb')
+      JtestR.applies_to?(self).should be_true
+    end
+    define('three', :base_dir => 'three') do
+      write _('src/spec/ruby/tc_three.rb')
+      JtestR.applies_to?(self).should be_true
+    end
+    define('four', :base_dir => 'four') do
+      write _('src/spec/ruby/ts_four.rb')
+      JtestR.applies_to?(self).should be_true
+    end
+  end
+
+  it 'should apply to projects having rspec sources' do
+    define('one', :base_dir => 'one') do
+      write _('src/spec/ruby/one_spec.rb')
+      JtestR.applies_to?(self).should be_true
+    end
+  end
+
+  it 'should apply to projects having expectations sources' do
+    define('one', :base_dir => 'one') do
+      write _('src/spec/ruby/one_expect.rb')
+      JtestR.applies_to?(self).should be_true
+    end
+  end
+
+  it 'should apply to projects having junit sources' do
+    define('one', :base_dir => 'one') do
+      write _('src/test/java/example/OneTest.java'), <<-JAVA
+        package example;
+        public class OneTest extends junit.framework.TestCase { }
+      JAVA
+      JtestR.applies_to?(self).should be_true
+    end
+  end
+
+  it 'should apply to projects having testng sources' do
+    define('one', :base_dir => 'one') do
+      write _('src/test/java/example/OneTest.java'), <<-JAVA
+        package example;
+        public class OneTest {
+           @org.testng.annotations.Test
+           public void testNothing() {}
+        }
+      JAVA
+      JtestR.applies_to?(self).should be_true
+    end
+  end
+
+  it 'should use a java compiler if java sources found' do
+    foo do
+      write _('src/spec/java/Something.java'), 'public class Something {}'
+      test.compile.language.should eql(:java)
+    end
+  end
+
+  it 'should load user jtestr_config.rb' do
+    foo do
+      hello = _('hello')
+      write('src/spec/ruby/jtestr_config.rb', "File.open('#{hello}', 'w') { |f| f.write 'HELLO' }")
+      write('src/spec/ruby/some_spec.rb')
+      test.invoke
+      File.should be_exist(hello)
+      File.read(hello).should == 'HELLO'
+    end
+  end
+
+  it 'should run junit tests' do
+    write('src/test/java/example/SuccessTest.java', <<-JAVA)
+        package example;
+        public class SuccessTest extends junit.framework.TestCase {
+           public void testSuccess() { assertTrue(true); }
+        }
+    JAVA
+    write('src/test/java/example/FailureTest.java', <<-JAVA)
+        package example;
+        public class FailureTest extends junit.framework.TestCase {
+           public void testFailure() { assertTrue(false); }
+        }
+    JAVA
+    foo do
+      lambda { test.invoke }.should raise_error(/Tests failed/)
+      test.tests.should include('example.SuccessTest', 'example.FailureTest')
+      test.failed_tests.should include('example.FailureTest')
+      test.passed_tests.should include('example.SuccessTest')
+    end
+  end
+
+  it 'should run testng tests' do
+    write('src/test/java/example/Success.java', <<-JAVA)
+        package example;
+        public class Success {
+          @org.testng.annotations.Test
+          public void annotatedSuccess() { org.testng.Assert.assertTrue(true); }
+        }
+    JAVA
+    write('src/test/java/example/Failure.java', <<-JAVA)
+        package example;
+        public class Failure {
+          @org.testng.annotations.Test
+          public void annotatedFail() { org.testng.Assert.fail("FAIL"); }
+        }
+    JAVA
+    foo do
+      lambda { test.invoke }.should raise_error(/Tests failed/)
+      test.tests.should include('example.Success', 'example.Failure')
+      test.failed_tests.should include('example.Failure')
+      test.passed_tests.should include('example.Success')
+    end
+  end
+
+  it 'should run test_unit' do
+    success = File.expand_path('src/spec/ruby/success_test.rb')
+    write(success, <<-TESTUNIT)
+      require 'test/unit'
+      class TC_Success < Test::Unit::TestCase
+        def test_success
+          assert true
+        end
+      end
+    TESTUNIT
+    failure = File.expand_path('src/spec/ruby/failure_test.rb')
+    write(failure, <<-TESTUNIT)
+      require 'test/unit'
+      class TC_Failure < Test::Unit::TestCase
+        def test_failure
+          assert false
+        end
+      end
+    TESTUNIT
+    error = File.expand_path('src/spec/ruby/error_test.rb')
+    write(error, <<-TESTUNIT)
+      require 'test/unit'
+      class TC_Error < Test::Unit::TestCase
+        def test_error
+          lambda;
+        end
+      end
+    TESTUNIT
+    foo do
+      lambda { test.invoke }.should raise_error(/Tests failed/)
+      test.tests.should include(success, failure, error)
+      test.failed_tests.should include(failure, error)
+      test.passed_tests.should include(success)
+    end
+  end
+
+  it 'should run expectations' do
+    success = File.expand_path('src/spec/ruby/success_expect.rb')
+    write(success, 'Expectations { expect(true) { true } }')
+    failure = File.expand_path('src/spec/ruby/failure_expect.rb')
+    write(failure, 'Expectations { expect(true) { false } }')
+    error = File.expand_path('src/spec/ruby/error_expect.rb')
+    write(error, 'Expectations { expect(nil) { lambda {}; } }')
+    foo do
+      lambda { test.invoke }.should raise_error(/Tests failed/)
+      test.tests.should include(success, failure, error)
+      test.failed_tests.should include(failure, error)
+      test.passed_tests.should include(success)
+    end
+  end
+
+  it 'should run rspecs' do
+    success = File.expand_path('src/spec/ruby/success_spec.rb')
+    write(success, 'describe("success") { it("is true") { nil.should be_nil } }')
+    failure = File.expand_path('src/spec/ruby/failure_spec.rb')
+    write(failure, 'describe("failure") { it("is false") { true.should == false } }')
+    error = File.expand_path('src/spec/ruby/error_spec.rb')
+    write(error, 'describe("error") { it("raises") { lambda; } }')
+    pending =  File.expand_path('src/spec/ruby/pending_spec.rb')
+    write(pending, 'describe("pending") { it "is not implemented" }')
+    foo do
+      lambda { test.invoke }.should raise_error(/Tests failed/)
+      test.tests.should include(success, failure, error)
+      test.failed_tests.should include(failure, error)
+      test.passed_tests.should include(success)
+    end
+  end
+
+  after do
+    # reset to default
+    Buildr.settings.build['junit'] = nil
+    Buildr::JUnit.instance_eval { @dependencies = nil }
+    Buildr::JtestR.instance_eval { @dependencies = nil }
+  end
+
+end if RUBY_PLATFORM =~ /java/ || ENV['JRUBY_HOME'] # JtestR
+
+describe Buildr::JBehave do
+  def foo(*args, &prc)
+    define('foo', *args) do
+      test.using :jbehave
+      if prc
+        instance_eval(&prc)
+      else
+        self
+      end
+    end
+  end
+
+  it 'should apply to projects having JBehave sources' do
+    define('one', :base_dir => 'one') do
+      write _('src/spec/java/SomeBehaviour.java'), 'public class SomeBehaviour {}'
+      JBehave.applies_to?(self).should be_true
+    end
+    define('two', :base_dir => 'two') do
+      write _('src/test/java/SomeBehaviour.java'), 'public class SomeBehaviour {}'
+      JBehave.applies_to?(self).should be_false
+    end
+    define('three', :base_dir => 'three') do
+      write _('src/spec/java/SomeBehavior.java'), 'public class SomeBehavior {}'
+      JBehave.applies_to?(self).should be_true
+    end
+    define('four', :base_dir => 'four') do
+      write _('src/test/java/SomeBehavior.java'), 'public class SomeBehavior {}'
+      JBehave.applies_to?(self).should be_false
+    end
+  end
+
+  it 'should be selected by :jbehave name' do
+    foo { test.framework.should eql(:jbehave) }
+  end
+
+  it 'should select a java compiler for its sources' do
+    write 'src/test/java/SomeBehavior.java', 'public class SomeBehavior {}'
+    foo do
+      test.compile.language.should eql(:java)
+    end
+  end
+
+  it 'should include JBehave dependencies' do
+    foo do
+      test.compile.dependencies.should include(artifact("org.jbehave:jbehave:jar::#{JBehave.version}"))
+      test.dependencies.should include(artifact("org.jbehave:jbehave:jar::#{JBehave.version}"))
+    end
+  end
+
+  it 'should include JMock dependencies' do
+    foo do
+      two_or_later = JMock.version[0,1].to_i >= 2
+      group = two_or_later ? "org.jmock" : "jmock"
+      test.compile.dependencies.should include(artifact("#{group}:jmock:jar:#{JMock.version}"))
+      test.dependencies.should include(artifact("#{group}:jmock:jar:#{JMock.version}"))
+    end
+  end
+
+  it 'should include classes whose name ends with Behavior' do
+    write 'src/spec/java/some/FooBehavior.java', <<-JAVA
+      package some;
+      public class FooBehavior {
+        public void shouldFoo() { assert true; }
+      }
+    JAVA
+    write 'src/spec/java/some/NotATest.java', <<-JAVA
+      package some;
+      public class NotATest { }
+    JAVA
+    foo.tap do |project|
+      project.test.invoke
+      project.test.tests.should include('some.FooBehavior')
+    end
+  end
+
+
+  it 'should include classes implementing Behaviours' do
+    write 'src/spec/java/some/MyBehaviours.java',  <<-JAVA
+      package some;
+      public class MyBehaviours implements
+      org.jbehave.core.behaviour.Behaviours {
+        public Class[] getBehaviours() {
+           return new Class[] { some.FooBehave.class };
+        }
+      }
+    JAVA
+    write 'src/spec/java/some/FooBehave.java', <<-JAVA
+      package some;
+      public class FooBehave {
+        public void shouldFoo() { assert true; }
+      }
+    JAVA
+    write 'src/spec/java/some/NotATest.java', <<-JAVA
+      package some;
+      public class NotATest { }
+    JAVA
+    foo.tap do |project|
+      project.test.invoke
+      project.test.tests.should include('some.MyBehaviours')
+    end
+  end
+
+end # JBehave

data/vendor/buildr/spec/java/cobertura_spec.rb

@@ -0,0 +1,112 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__), 'test_coverage_helper'))
+Sandbox.require_optional_extension 'buildr/java/cobertura'
+artifacts(Buildr::Cobertura::dependencies).map(&:invoke)
+
+
+describe Buildr::Cobertura do
+  before do
+    # Reloading the extension because the sandbox removes all its actions
+    Buildr.module_eval { remove_const :Cobertura }
+    load File.expand_path('../lib/buildr/java/cobertura.rb')
+    @tool_module = Buildr::Cobertura
+  end
+
+  it_should_behave_like 'test coverage tool'
+
+  describe 'project-specific' do
+
+    describe 'data file' do
+      it 'should have a default value' do
+        define('foo').cobertura.data_file.should point_to_path('reports/cobertura.ser')
+      end
+
+      it 'should be overridable' do
+        define('foo') { cobertura.data_file = path_to('target/data.cobertura') }
+        project('foo').cobertura.data_file.should point_to_path('target/data.cobertura')
+      end
+
+      it 'should be created during instrumentation' do
+        write 'src/main/java/Foo.java', 'public class Foo {}'
+        define('foo')
+        task('foo:cobertura:instrument').invoke
+        file(project('foo').cobertura.data_file).should exist
+      end
+
+      it 'should not instrument projects which have no sources' do
+        write 'bar/src/main/java/Baz.java', 'public class Baz {}'
+        define('foo') { define('bar') }
+        task('foo:bar:cobertura:instrument').invoke
+      end
+      
+      it 'should not generate html if projects have no sources' do
+        define('foo') { define('bar') }
+        task('cobertura:html').invoke
+      end
+    end
+
+    describe 'instrumentation' do
+      before do
+        ['Foo', 'Bar'].each { |cls| write File.join('src/main/java', "#{cls}.java"), "public class #{cls} {}" }
+      end
+
+      it 'should instrument only included classes' do
+        define('foo') { cobertura.include 'Foo' }
+        task("foo:cobertura:instrument").invoke
+        Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Foo.class'] }
+      end
+
+      it 'should not instrument excluded classes' do
+        define('foo') { cobertura.exclude 'Foo' }
+        task("foo:cobertura:instrument").invoke
+        Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Bar.class'] }
+      end
+
+      it 'should instrument classes that are included but not excluded' do
+        write 'src/main/java/Baz.java', 'public class Baz {}'
+        define('foo') { cobertura.include('Ba').exclude('ar') }
+        task("foo:cobertura:instrument").invoke
+        Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Baz.class'] }
+      end
+    end
+
+    describe 'check' do
+      before do
+        write 'src/main/java/Foo.java', 'public class Foo { public static boolean returnTrue() {return true;}}'
+        write 'src/test/java/FooTest.java', <<-JAVA
+import static junit.framework.Assert.assertTrue;
+import org.junit.Test;
+
+public class FooTest { 
+  
+  @Test
+  public void testReturnTrue() { 
+    assertTrue(Foo.returnTrue());
+  }
+}
+JAVA
+      end
+      
+      it 'should not raise errors during execution' do
+        define('foo')  { cobertura.include 'Foo' }
+        lambda {task("foo:cobertura:check").invoke}.should_not raise_error
+      end
+      
+    end
+  end
+end