buildr 1.3.0-java

data/spec/build_spec.rb

@@ -0,0 +1,193 @@
+# 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.join(File.dirname(__FILE__), 'spec_helpers')
+
+
+describe 'local task', :shared=>true do
+  it "should execute task for project in current directory" do
+    define 'foobar'
+    lambda { @task.invoke }.should run_task("foobar:#{@task.name}")
+  end
+
+  it "should not execute task for projects in other directory" do
+    define 'foobar', :base_dir=>'elsewhere'
+    lambda { task('build').invoke }.should_not run_task('foobar:build')
+  end
+end
+
+
+describe 'build task' do
+  it_should_behave_like 'local task'
+  before(:each) { @task = task('build') }
+end
+
+describe 'clean task' do
+  it_should_behave_like 'local task'
+  before(:each) { @task = task('clean') }
+end
+
+describe 'package task' do
+  it_should_behave_like 'local task'
+  before(:each) { @task = task('package') }
+
+  it 'should execute build task as prerequisite' do
+    lambda { @task.invoke }.should run_task('build')
+  end
+end
+
+describe 'install task' do
+  it_should_behave_like 'local task'
+  before(:each) { @task = task('install') }
+
+  it 'should execute package task as prerequisite' do
+    lambda { @task.invoke }.should run_task('package')
+  end
+end
+
+describe 'uninstall task' do
+  it_should_behave_like 'local task'
+  before(:each) { @task = task('uninstall') }
+end
+
+describe 'upload task' do
+  it_should_behave_like 'local task'
+  before(:each) { @task = task('upload') }
+
+  it 'should execute package task as prerequisite' do
+    lambda { @task.invoke }.should run_task('package')
+  end
+end
+
+
+describe Project, '#build' do
+  it 'should return the project\'s build task' do
+    define('foo').build.should eql(task('foo:build'))
+  end
+
+  it 'should enhance the project\'s build task' do
+    task 'prereq'
+    task 'action'
+    define 'foo' do
+      build 'prereq' do
+        task('action').invoke
+      end
+    end
+    lambda { project('foo').build.invoke }.should run_tasks('prereq', 'action')
+  end
+
+  it 'should execute build task for sub-project' do
+    define 'foo' do
+      define 'bar'
+    end
+    lambda { task('foo:build').invoke }.should run_task('foo:bar:build')
+  end
+
+  it 'should not execute build task of other projects' do
+    define 'foo'
+    define 'bar'
+    lambda { task('foo:build').invoke }.should_not run_task('bar:build')
+  end
+end
+
+
+describe Project, '#clean' do
+  it 'should return the project\'s clean task' do
+    define('foo').clean.should eql(task('foo:clean'))
+  end
+
+  it 'should enhance the project\'s clean task' do
+    task 'prereq'
+    task 'action'
+    define 'foo' do
+      clean 'prereq' do
+        task('action').invoke
+      end
+    end
+    lambda { project('foo').clean.invoke }.should run_tasks('prereq', 'action')
+  end
+
+  it 'should remove target directory' do
+    define 'foo' do
+      self.layout[:target] = 'targeted'
+    end
+    mkpath 'targeted'
+    lambda { project('foo').clean.invoke }.should change { File.exist?('targeted') }.from(true).to(false)
+  end
+
+  it 'should remove reports directory' do
+    define 'foo' do
+      self.layout[:reports] = 'reported'
+    end
+    mkpath 'reported'
+    lambda { project('foo').clean.invoke }.should change { File.exist?('reported') }.from(true).to(false)
+  end
+
+  it 'should execute clean task for sub-project' do
+    define 'foo' do
+      define 'bar'
+    end
+    lambda { task('foo:clean').invoke }.should run_task('foo:bar:clean')
+  end
+
+  it 'should not execute clean task of other projects' do
+    define 'foo'
+    define 'bar'
+    lambda { task('foo:clean').invoke }.should_not run_task('bar:clean')
+  end
+end
+
+
+describe Project, '#target' do
+  before :each do
+    @project = define('foo', :layout=>Layout.new)
+  end
+
+  it 'should default to target' do
+    @project.target.should eql('target')
+  end
+
+  it 'should set layout :target' do
+    @project.target = 'bar'
+    @project.layout.expand(:target).should point_to_path('bar')
+  end
+
+  it 'should come from layout :target' do
+    @project.layout[:target] = 'baz'
+    @project.target.should eql('baz')
+  end
+end
+
+
+describe Project, '#reports' do
+  before :each do
+    @project = define('foo', :layout=>Layout.new)
+  end
+
+  it 'should default to reports' do
+    @project.reports.should eql('reports')
+  end
+
+  it 'should set layout :reports' do
+    @project.reports = 'bar'
+    @project.layout.expand(:reports).should point_to_path('bar')
+  end
+
+  it 'should come from layout :reports' do
+    @project.layout[:reports] = 'baz'
+    @project.reports.should eql('baz')
+  end
+end

data/spec/checks_spec.rb

@@ -0,0 +1,537 @@
+# 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.join(File.dirname(__FILE__), 'spec_helpers')
+
+
+describe Project, " check task" do
+
+  it "should execute last thing from package task" do
+    task "action"
+    define "foo", :version=>"1.0" do
+      package :jar
+      task("package").enhance { task("action").invoke }
+    end
+    lambda { project("foo").task("package").invoke }.should run_tasks(["foo:package", "action", "foo:check"])
+  end
+
+  it "should execute all project's expectations" do
+    task "expectation"
+    define "foo", :version=>"1.0" do
+      check  { task("expectation").invoke } 
+    end
+    lambda { project("foo").task("package").invoke }.should run_task("expectation")
+  end
+
+  it "should succeed if there are no expectations" do
+    define "foo", :version=>"1.0"
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should succeed if all expectations passed" do
+    define "foo", :version=>"1.0" do
+      check { true }
+      check { false }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if any expectation failed" do
+    define "foo", :version=>"1.0" do
+      check
+      check { fail "sorry" } 
+      check
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end
+
+
+describe Project, "#check" do
+
+  it "should add expectation" do
+    define "foo" do
+      expectations.should be_empty
+      check
+      expectations.size.should be(1)
+    end
+  end
+
+  it "should treat no arguments as expectation against project" do
+    define "foo" do
+      subject = self
+      check do
+        it.should be(subject)
+        description.should eql(subject.to_s)
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should treat single string argument as description, expectation against project" do
+    define "foo" do
+      subject = self
+      check "should be project" do
+        it.should be(subject)
+        description.should eql("#{subject} should be project")
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should treat single object argument as subject" do
+    define "foo" do
+      subject = Object.new
+      check subject do
+        it.should be(subject)
+        description.should eql(subject.to_s)
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should treat first object as subject, second object as description" do
+    define "foo" do
+      subject = Object.new
+      check subject, "should exist" do
+        it.should be(subject)
+        description.should eql("#{subject} should exist")
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should work without block" do
+    define "foo" do
+      check "implement later"
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " matchers" do
+
+  it "should include Buildr matchers exist and contain" do
+    define "foo" do
+      check do
+        self.should respond_to(:exist)
+        self.should respond_to(:contain)
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should include RSpec matchers like be and eql" do
+    define "foo" do
+      check do
+        self.should respond_to(:be)
+        self.should respond_to(:eql)
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should include RSpec predicates like be_nil and be_empty" do
+    define "foo" do
+      check do
+        nil.should be_nil
+        [].should be_empty
+      end
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " exist" do
+
+  it "should pass if file exists" do
+    define "foo" do
+      build file("test") { |task| write task.name }
+      check(file("test")) { it.should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if file does not exist" do
+    define "foo" do
+      check(file("test")) { it.should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should not attempt to invoke task" do
+    define "foo" do
+      file("test") { |task| write task.name }
+      check(file("test")) { it.should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should pass if ZIP path exists" do
+    write "resources/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if ZIP path does not exist" do
+    mkpath "resources"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar)) { it.path("not-resources").should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should pass if ZIP entry exists" do
+    write "resources/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should exist }
+      check(package(:jar).path("resources").entry("test")) { it.should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if ZIP path does not exist" do
+    mkpath "resources"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should exist }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " exist" do
+
+  it "should pass if file has no content" do
+    define "foo" do
+      build file("test") { write "test" }
+      check(file("test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if file has content" do
+    define "foo" do
+      build file("test") { write "test", "something" }
+      check(file("test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if file does not exist" do
+    define "foo" do
+      check(file("test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should pass if directory is empty" do
+    define "foo" do
+      build file("test") { mkpath "test" }
+      check(file("test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if directory has any files" do
+    define "foo" do
+      build file("test") { write "test/file" }
+      check(file("test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should pass if ZIP path is empty" do
+    mkpath "resources"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if ZIP path has any entries" do
+    write "resources/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should pass if ZIP entry has no content" do
+    write "resources/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should be_empty }
+      check(package(:jar).path("resources").entry("test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail if ZIP entry has content" do
+    write "resources/test", "something"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if ZIP entry does not exist" do
+    mkpath "resources"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should be_empty }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " contain(file)" do
+
+  it "should pass if file content matches string" do
+    define "foo" do
+      build file("test") { write "test", "something" }
+      check(file("test")) { it.should contain("thing") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if file content matches pattern" do
+    define "foo" do
+      build file("test") { write "test", "something\nor\nanother" }
+      check(file("test")) { it.should contain(/or/) }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if file content matches all arguments" do
+    define "foo" do
+      build file("test") { write "test", "something\nor\nanother" }
+      check(file("test")) { it.should contain(/or/, /other/) }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail unless file content matchs all arguments" do
+    define "foo" do
+      build file("test") { write "test", "something" }
+      check(file("test")) { it.should contain(/some/, /other/) }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if file content does not match" do
+    define "foo" do
+      build file("test") { write "test", "something" }
+      check(file("test")) { it.should contain(/other/) }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if file does not exist" do
+    define "foo" do
+      check(file("test")) { it.should contain(/anything/) }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " contain(directory)" do
+
+  it "should pass if directory contains file" do
+    write "resources/test"
+    define "foo" do
+      check(file("resources")) { it.should contain("test") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if directory contains glob pattern" do
+    write "resources/with/test"
+    define "foo" do
+      check(file("resources")) { it.should contain("**/t*st") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if directory contains all arguments" do
+    write "resources/with/test"
+    define "foo" do
+      check(file("resources")) { it.should contain("**/test", "**/*") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail unless directory contains all arguments" do
+    write "resources/test"
+    define "foo" do
+      check(file("resources")) { it.should contain("test", "or-not") }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if directory is empty" do
+    mkpath "resources"
+    define "foo" do
+      check(file("resources")) { it.should contain("test") }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if directory does not exist" do
+    define "foo" do
+      check(file("resources")) { it.should contain }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " contain(zip.entry)" do
+
+  it "should pass if ZIP entry content matches string" do
+    write "resources/test", "something"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should contain("thing") }
+      #check(package(:jar)) { it.entry("resources/test").should contain("thing") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if ZIP entry content matches pattern" do
+    write "resources/test", "something\nor\another"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should contain(/or/) }
+      #check(package(:jar)) { it.entry("resources/test").should contain(/or/) }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if ZIP entry content matches all arguments" do
+    write "resources/test", "something\nor\nanother"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should contain(/or/, /other/) }
+      #check(package(:jar)) { it.entry("resources/test").should contain(/or/, /other/) }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail unless ZIP path contains all arguments" do
+    write "resources/test", "something"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should contain(/some/, /other/) }
+      #check(package(:jar)) { it.entry("resources/test").should contain(/some/, /other/) }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if ZIP entry content does not match" do
+    write "resources/test", "something"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should contain(/other/) }
+      #check(package(:jar)) { it.entry("resources/test").should contain(/other/) }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if ZIP entry does not exist" do
+    mkpath "resources"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).entry("resources/test")) { it.should contain(/anything/) }
+      #check(package(:jar)) { it.entry("resources/test").should contain(/anything/) }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end
+
+
+describe Buildr::Checks::Expectation, " contain(zip.path)" do
+
+  it "should pass if ZIP path contains file" do
+    write "resources/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should contain("test") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should handle deep nesting" do
+    write "resources/test/test2.efx"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("*")
+      check(package(:jar)) { it.should contain("resources/test/test2.efx") }
+      check(package(:jar).path("resources")) { it.should contain("test/test2.efx") }
+      check(package(:jar).path("resources/test")) { it.should contain("test2.efx") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+
+  it "should pass if ZIP path contains pattern" do
+    write "resources/with/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should contain("**/t*st") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should pass if ZIP path contains all arguments" do
+    write "resources/with/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should contain("**/test", "**/*") }
+    end
+    lambda { project("foo").task("package").invoke }.should_not raise_error
+  end
+
+  it "should fail unless ZIP path contains all arguments" do
+    write "resources/test"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should contain("test", "or-not") }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+
+  it "should fail if ZIP path is empty" do
+    mkpath "resources"
+    define "foo", :version=>"1.0" do
+      package(:jar).include("resources")
+      check(package(:jar).path("resources")) { it.should contain("test") }
+    end
+    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks failed/)
+  end
+end