buildr 1.4.6-x86-mswin32 → 1.4.7-x86-mswin32

data/spec/core/application_spec.rb

@@ -133,8 +133,9 @@ describe Buildr::Application do
       write 'build.yaml', <<-YAML
         gems:
         - rake
-        - rspec ~> 2.1.0
+        - rspec ~> 2.9.0
       YAML
+      Buildr.application.should_receive(:listed_gems).and_return([[Gem.loaded_specs['rspec'],Gem.loaded_specs['rake']],[]])
       Buildr.application.load_gems
     end
 
@@ -181,71 +182,20 @@ describe Buildr::Application do
     end
 
     it 'should install nothing if specified gems already installed' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem.loaded_specs['rspec']])
+      Buildr.application.should_receive(:listed_gems).and_return([[Gem.loaded_specs['rspec']],[]])
       Util.should_not_receive(:ruby)
       lambda { Buildr.application.load_gems }.should_not raise_error
     end
 
-    it 'should fail if required gem not found in remote repository' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).at_least(:once).and_return([])
+    it 'should fail if required gem not installed' do
+      Buildr.application.should_receive(:listed_gems).and_return([[],[Gem::Dependency.new('buildr-foo', '>=1.1')]])
       lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot be found/i)
     end
 
-    it 'should fail if need to install gem and not running in interactive mode' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).and_return([@spec])
-      $stdout.should_receive(:isatty).and_return(false)
-      lambda { Buildr.application.load_gems }.should raise_error(LoadError, /this build requires the gems/i)
-    end
-
-    it 'should ask permission before installing required gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).and_return([@spec])
-      $terminal.should_receive(:agree).with(/install/, true)
-      lambda { Buildr.application.load_gems }.should raise_error
-    end
-
-    it 'should fail if permission not granted to install gem' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).and_return([@spec])
-      $terminal.should_receive(:agree).and_return(false)
-      lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot build without/i)
-    end
-
-    it 'should install gem if permission granted' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).and_return([@spec])
-      $terminal.should_receive(:agree).and_return(true)
-      Util.should_receive(:ruby) do |*args|
-        args.should include('install', 'buildr-foo', '-v', '1.2')
-      end
-      Buildr.application.should_receive(:gem).and_return(false)
-      Buildr.application.load_gems
-    end
-
-    it 'should reload gem cache after installing required gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).and_return([@spec])
-      $terminal.should_receive(:agree).and_return(true)
-      Util.should_receive(:ruby)
-      Gem.source_index.should_receive(:load_gems_in).with(Gem::SourceIndex.installed_spec_directories)
-      Buildr.application.should_receive(:gem).and_return(false)
-      Buildr.application.load_gems
-    end
-
     it 'should load previously installed gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem.loaded_specs['rspec']])
-      Buildr.application.should_receive(:gem).with('rspec', Gem.loaded_specs['rspec'].version.to_s)
-      Buildr.application.load_gems
-    end
-
-    it 'should load newly installed gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
-      Gem.source_index.should_receive(:search).and_return([@spec])
-      $terminal.should_receive(:agree).and_return(true)
-      Util.should_receive(:ruby)
-      Buildr.application.should_receive(:gem).with('buildr-foo', @spec.version.to_s)
+      Gem.loaded_specs['rspec'].should_receive(:activate)
+      Buildr.application.should_receive(:listed_gems).and_return([[Gem.loaded_specs['rspec']],[]])
+      #Buildr.application.should_receive(:gem).with('rspec', Gem.loaded_specs['rspec'].version.to_s)
       Buildr.application.load_gems
     end
 
@@ -270,12 +220,9 @@ describe Buildr::Application do
     end
 
     def should_attempt_to_load_dependency(dep)
-      Gem.source_index.should_receive(:search).with(dep).and_return([])
-      lambda { Buildr.application.load_gems }.should raise_missing_gem_error(dep)
-    end
-
-    def raise_missing_gem_error(dep)
-      raise_error(Gem::LoadError, /Build requires the gems #{dep.name} #{dep.requirement}, which cannot be found in local or remote repository./)
+      missing_gems = Buildr.application.send(:listed_gems)[1]
+      missing_gems.size.should eql(1)
+      missing_gems[0].eql?(dep)
     end
   end
 

data/spec/core/cc_spec.rb

@@ -92,21 +92,29 @@ describe Buildr::CCTask do
         foo.cc.invoke
       rescue => e
         p "unexpected exception #{e.inspect}"
-        p e.backtrace.join("\n").inspect
+        p e.backtrace.join("\n")
       end
     end
 
-    sleep 1
+    #Ick! Try to get the sleeping enough on each platform that the tests reliably pass
+    sleep 1 if RUBY_VERSION >= '1.9' && !RUBY_PLATFORM[/java/]
+    sleep 5 if RUBY_VERSION >= '1.8.7' && !RUBY_PLATFORM[/java/]
+    sleep 1 if RUBY_PLATFORM[/java/]
 
     foo.compile.run_count.should == 1
     foo.test.compile.run_count.should == 1
     foo.resources.run_count.should == 1
 
-    sleep 1 # Wait one sec as the timestamp needs to be different.
+    # Wait some time as the timestamp needs to be different on files.
+    sleep 3 if Buildr::Util.win_os?
+    sleep 1 unless Buildr::Util.win_os?
 
     touch File.join(Dir.pwd, 'src/main/java/Example.java')
 
-    sleep 1
+    #Ick! Try to get the sleeping enough on each platform that the tests reliably pass
+    sleep 1 if RUBY_VERSION >= '1.9' && !RUBY_PLATFORM[/java/]
+    sleep 5 if RUBY_VERSION >= '1.8.7' && !RUBY_PLATFORM[/java/]
+    sleep 1 if RUBY_PLATFORM[/java/]
 
     foo.compile.run_count.should == 2
     foo.test.compile.run_count.should == 2
@@ -195,7 +203,6 @@ describe Buildr::CCTask do
     tstamp = File.mtime("foo/target/classes/Example.class")
 
     touch 'foo/src/main/java/Example.java'
-    p "after touch"
     sleep 2
 
     project("container:foo").tap do |p|

data/spec/core/compile_spec.rb

@@ -413,6 +413,17 @@ describe Buildr::CompileTask, '#invoke' do
       lambda { compile.from('sources').invoke }.should raise_error(RuntimeError, /no compiler selected/i)
     end
   end
+
+  it 'should not unnecessarily recompile files explicitly added to compile list (BUILDR-611)' do
+    mkpath 'src/other'
+    write 'src/other/Foo.java', 'package foo; public class Foo {}'
+    compile_task.from FileList['src/other/**.java']
+    mkpath 'target/classes/foo'
+    touch 'target/classes/foo/Foo.class'
+    File.utime(Time.now - 10, Time.now - 10, compile_task.target.to_s)
+    compile_task.invoke
+    File.stat(compile_task.target.to_s).mtime.should be_close(Time.now - 10, 2)
+  end
 end
 
 

data/spec/core/doc_spec.rb

@@ -124,7 +124,7 @@ describe Project, '#doc' do
       compile.using(:javac)
       doc.include included
     end
-    project('foo').doc.source_files.should include(included)
+    project('foo').doc.source_files.should include(File.expand_path(included))
   end
 
   it 'should respond to exclude() and return self' do

data/spec/core/run_spec.rb

@@ -27,13 +27,20 @@ describe Project, :run do
     project('foo').run.should be_kind_of(Run::RunTask)
   end
 
-  it 'should include compile and test.compile dependencies' do
+  it 'should include compile dependencies' do
     define('foo') do
       compile.using(:javac).with 'group:compile:jar:1.0'
       test.compile.using(:javac).with 'group:test:jar:1.0'
     end
     project('foo').run.classpath.should include(artifact('group:compile:jar:1.0'))
-    project('foo').run.classpath.should include(artifact('group:test:jar:1.0'))
+  end
+  
+  it 'should not include test dependencies' do
+    define('foo') do
+      compile.using(:javac).with 'group:compile:jar:1.0'
+      test.compile.using(:javac).with 'group:test:jar:1.0'
+    end
+    project('foo').run.classpath.should_not include(artifact('group:test:jar:1.0'))
   end
 
   it 'should respond to using() and return self' do
@@ -63,11 +70,17 @@ describe Project, :run do
     end
     project('foo').run.runner.should be_a(Run::JavaRunner)
   end
+  
+  it "should run with the project resources" do
+    write 'src/main/java/Test.java', 'class Test {}'
+    write 'src/main/resources/test.properties', ''
+    define 'foo'
+    project('foo').run.classpath.should include project('foo').resources.target
+  end
 
-  it 'should depend on project''s compile and test.compile task' do
+  it 'should depend on project''s compile task' do
     define 'foo'
     project('foo').run.prerequisites.should include(project('foo').compile)
-    project('foo').run.prerequisites.should include(project('foo').test)
   end
 
   it 'should be local task' do

data/spec/core/test_spec.rb

@@ -747,9 +747,11 @@ describe Rake::Task, 'test' do
   end
 
   it 'should stop at first failure' do
-    define('foo') { test { fail } }
-    define('bar') { test { fail } }
-    lambda { task('test').invoke rescue nil }.should run_tasks('foo:test').but_not('bar:test')
+    define('myproject') do
+      define('foo') { test { fail } }
+      define('bar') { test { fail } }
+    end
+    lambda { task('test').invoke rescue nil }.should run_tasks('myproject:bar:test').but_not('myproject:foo:test')
   end
 
   it 'should ignore failure if options.test is :all' do

data/spec/ide/idea_spec.rb

@@ -296,6 +296,66 @@ describe Buildr::IntellijIdea do
       end
     end
 
+    describe "with artifacts added to root project" do
+      before do
+        @foo = define "foo" do
+          ipr.add_artifact("MyFancy.jar", "jar") do |xml|
+            xml.tag!('output-path', project._(:artifacts, "MyFancy.jar"))
+            xml.element :id => "module-output", :name => "foo"
+          end
+          ipr.add_artifact("MyOtherFancy.jar", "jar") do |xml|
+            xml.tag!('output-path', project._(:artifacts, "MyOtherFancy.jar"))
+            xml.element :id => "module-output", :name => "foo"
+          end
+        end
+        invoke_generate_task
+      end
+
+      it "generates an IPR with multiple jar artifacts" do
+        doc = xml_document(@foo._("foo.ipr"))
+        facet_xpath = "/project/component[@name='ArtifactManager']/artifact"
+        doc.should have_nodes(facet_xpath, 2)
+        doc.should have_xpath("#{facet_xpath}[@type='jar', @name='MyFancy.jar']")
+        doc.should have_xpath("#{facet_xpath}[@type='jar', @name='MyOtherFancy.jar']")
+      end
+    end
+
+    describe "with configurations added to root project" do
+      before do
+        @foo = define "foo" do
+          ipr.add_configuration("Run Contacts.html", "GWT.ConfigurationType", "GWT Configuration") do |xml|
+            xml.module(:name => project.iml.id)
+            xml.option(:name => "RUN_PAGE", :value => "Contacts.html")
+            xml.option(:name => "compilerParameters", :value => "-draftCompile -localWorkers 2")
+            xml.option(:name => "compilerMaxHeapSize", :value => "512")
+
+            xml.RunnerSettings(:RunnerId => "Run")
+            xml.ConfigurationWrapper(:RunnerId => "Run")
+            xml.tag! :method
+          end
+          ipr.add_configuration("Run Planner.html", "GWT.ConfigurationType", "GWT Configuration") do |xml|
+            xml.module(:name => project.iml.id)
+            xml.option(:name => "RUN_PAGE", :value => "Planner.html")
+            xml.option(:name => "compilerParameters", :value => "-draftCompile -localWorkers 2")
+            xml.option(:name => "compilerMaxHeapSize", :value => "512")
+
+            xml.RunnerSettings(:RunnerId => "Run")
+            xml.ConfigurationWrapper(:RunnerId => "Run")
+            xml.tag! :method
+          end
+        end
+        invoke_generate_task
+      end
+
+      it "generates an IPR with multiple configurations" do
+        doc = xml_document(@foo._("foo.ipr"))
+        facet_xpath = "/project/component[@name='ProjectRunConfigurationManager']/configuration"
+        doc.should have_nodes(facet_xpath, 2)
+        doc.should have_xpath("#{facet_xpath}[@type='GWT.ConfigurationType', @name='Run Contacts.html']")
+        doc.should have_xpath("#{facet_xpath}[@type='GWT.ConfigurationType', @name='Run Planner.html']")
+      end
+    end
+
     describe "with iml.group specified" do
       before do
         @foo = define "foo" do

data/spec/java/bdd_spec.rb

@@ -28,6 +28,10 @@ describe Buildr::RSpec do
   end
 
   it 'should read passed specs from result yaml' do
+    # This test fails on the CI machine if the spec is run as part of a suite but not if run individually
+    # This seems to indicate that there is interaction with some other test but until that other test is
+    # identified the test has been marked as pending on the ci box
+    pending "Unable to determine why it fails on the CI machine so disabling" if `hostname` == "vesta.apache.org\n"
     write('src/spec/ruby/success_spec.rb', 'describe("success") { it("is true") { nil.should be_nil } }')
 
     project('foo').test.invoke
@@ -35,6 +39,10 @@ describe Buildr::RSpec do
   end
 
   it 'should read result yaml to obtain the list of failed specs' do
+    # This test fails on the CI machine if the spec is run as part of a suite but not if run individually
+    # This seems to indicate that there is interaction with some other test but until that other test is
+    # identified the test has been marked as pending on the ci box
+    pending "Unable to determine why it fails on the CI machine so disabling" if `hostname` == "vesta.apache.org\n"
     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')
@@ -51,224 +59,6 @@ describe Buildr::RSpec do
 
 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 ENV["JTESTR"] && (RUBY_PLATFORM =~ /java/ || ENV['JRUBY_HOME']) # JtestR
-
 describe Buildr::JBehave do
   def foo(*args, &prc)
     define('foo', *args) do