ittayd-buildr 1.3.4 → 1.3.5

data/spec/sandbox.rb

@@ -1,139 +0,0 @@
-# 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.
-
-
-# The local repository we use for testing is void of any artifacts, which will break given
-# that the code requires several artifacts. So we establish them first using the real local
-# repository and cache these across test cases.
-Buildr.application.instance_eval { @rakefile = File.expand_path('buildfile') }
-repositories.remote << 'http://repo1.maven.org/maven2'
-repositories.remote << 'http://scala-tools.org/repo-releases'
-
-# Add a 'require' here only for optional extensions, not for extensions that should be loaded by default.
-require 'buildr/groovy'
-
-Java.load # Anything added to the classpath.
-artifacts(TestFramework.frameworks.map(&:dependencies).flatten, JUnit.ant_taskdef).each do |path|
-  file(path).invoke
-end
-
-ENV['HOME'] = File.expand_path('tmp/home')
-
-# We need to run all tests inside a _sandbox, tacking a snapshot of Buildr before the test,
-# and restoring everything to its previous state after the test. Damn state changes.
-module Sandbox
-
-  class << self
-    attr_reader :tasks, :rules
-
-    def included(spec)
-      spec.before(:each) { sandbox }
-      spec.after(:each) { reset }
-    end
-    
-    # Require an optional extension without letting its callbacks pollute the Project class.
-    def require_optional_extension(extension_require_path)
-      project_callbacks_without_extension = Project.class_eval { @callbacks }.dup
-      begin
-        require extension_require_path
-      ensure
-        Project.class_eval { @callbacks = project_callbacks_without_extension }
-      end
-    end
-  end
-
-  @tasks = Buildr.application.tasks.collect do |original|
-    prerequisites = original.send(:prerequisites).map(&:to_s)
-    actions = original.instance_eval { @actions }.clone
-    lambda do
-      original.class.send(:define_task, original.name=>prerequisites).tap do |task|
-        task.comment = original.comment
-        actions.each { |action| task.enhance &action }
-      end
-    end
-  end
-  @rules = Buildr.application.instance_variable_get(:@rules)
-
-  def sandbox
-    @_sandbox = {}
-    
-    # Create a temporary directory where we can create files, e.g,
-    # for projects, compilation. We need a place that does not depend
-    # on the current directory.
-    @_sandbox[:original_dir] = Dir.pwd
-    @temp = File.join(File.dirname(__FILE__), '../tmp')
-    FileUtils.mkpath @temp
-    Dir.chdir @temp
-
-    ARGV.clear
-    Buildr.application = Buildr::Application.new
-    Sandbox.tasks.each { |block| block.call }
-    Buildr.application.instance_variable_set :@rules, Sandbox.rules.clone
-    Buildr.application.instance_eval { @rakefile = File.expand_path('buildfile') }
-
-    @_sandbox[:load_path] = $LOAD_PATH.clone
-    #@_sandbox[:loaded_features] = $LOADED_FEATURES.clone
-    
-    # Later on we'll want to lose all the on_define created during the test.
-    @_sandbox[:on_define] = Project.class_eval { (@on_define || []).dup }
-    @_sandbox[:callbacks] = Project.class_eval { (@callbacks || []).dup }
-    @_sandbox[:layout] = Layout.default.clone
-
-    # Create a local repository we can play with. However, our local repository will be void
-    # of some essential artifacts (e.g. JUnit artifacts required by build task), so we create
-    # these first (see above) and keep them across test cases.
-    @_sandbox[:artifacts] = Artifact.class_eval { @artifacts }.clone
-    Buildr.repositories.local = File.expand_path('repository')
-    ENV['HOME'] = File.expand_path('home')
-    ENV['BUILDR_ENV'] = 'development'
-
-    @_sandbox[:env_keys] = ENV.keys
-    ['DEBUG', 'TEST', 'HTTP_PROXY', 'USER'].each { |k| ENV.delete(k) ; ENV.delete(k.downcase) }
-
-    # Remove testing local repository, and reset all repository settings.
-    Buildr.repositories.instance_eval do
-      @local = @remote = @release_to = nil
-    end
-    Buildr.options.proxy.http = nil
-
-    # Don't output crap to the console.
-    trace false
-    verbose false
-  end
-
-  # Call this from teardown.
-  def reset
-    # Get rid of all the projects and the on_define blocks we used.
-    Project.clear
-    on_define = @_sandbox[:on_define]
-    Project.class_eval { @on_define = on_define }
-    callbacks = @_sandbox[:callbacks]
-    Project.class_eval { @callbacks = callbacks }
-    Layout.default = @_sandbox[:layout].clone
-
-    $LOAD_PATH.replace @_sandbox[:load_path]
-    FileUtils.rm_rf @temp
-
-    # Get rid of all artifacts.
-    @_sandbox[:artifacts].tap { |artifacts| Artifact.class_eval { @artifacts = artifacts } }
-
-    # Restore options.
-    Buildr.options.test = nil
-    (ENV.keys - @_sandbox[:env_keys]).each { |key| ENV.delete key }
-
-    Dir.chdir @_sandbox[:original_dir]
-  end
-
-end

data/spec/scala/compiler_spec.rb

@@ -1,228 +0,0 @@
-# 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 'scalac compiler' do
-  it 'should identify itself from source directories' do
-    write 'src/main/scala/com/example/Test.scala', 'package com.example; class Test { val i = 1 }' 
-    define('foo').compile.compiler.should eql(:scalac)
-  end
-
-  it 'should report the language as :scala' do
-    define('foo').compile.using(:scalac).language.should eql(:scala)
-  end
-
-  it 'should set the target directory to target/classes' do
-    define 'foo' do
-      lambda { compile.using(:scalac) }.should change { compile.target.to_s }.to(File.expand_path('target/classes'))
-    end
-  end
-
-  it 'should not override existing target directory' do
-    define 'foo' do
-      compile.into('classes')
-      lambda { compile.using(:scalac) }.should_not change { compile.target }
-    end
-  end
-
-  it 'should not change existing list of sources' do
-    define 'foo' do
-      compile.from('sources')
-      lambda { compile.using(:scalac) }.should_not change { compile.sources }
-    end
-  end
-
-  it 'should include as classpath dependency' do
-    write 'src/dependency/Dependency.scala', 'class Dependency {}'
-    define 'dependency', :version=>'1.0' do
-      compile.from('src/dependency').into('target/dependency')
-      package(:jar)
-    end
-    write 'src/test/DependencyTest.scala', 'class DependencyTest { var d: Dependency = _ }'
-    lambda { define('foo').compile.from('src/test').with(project('dependency')).invoke }.should run_task('foo:compile')
-    file('target/classes/DependencyTest.class').should exist
-  end
-
-  def define_test1_project
-    write 'src/main/scala/com/example/Test1.scala', 'package com.example; class Test1 { val i = 1 }'
-    define 'test1', :version=>'1.0' do
-      package(:jar)
-    end
-  end
-  
-  it 'should compile a simple .scala file into a .class file' do
-    define_test1_project
-    task('test1:compile').invoke
-    file('target/classes/com/example/Test1.class').should exist
-  end
-
-  it 'should package .class into a .jar file' do
-    define_test1_project
-    task('test1:package').invoke
-    file('target/test1-1.0.jar').should exist
-    Zip::ZipFile.open(project('test1').package(:jar).to_s) do |zip|
-      zip.file.exist?('com/example/Test1.class').should be_true
-    end
-  end
-
-end
-
-
-describe 'scalac compiler options' do
-  def compile_task
-    @compile_task ||= define('foo').compile.using(:scalac)
-  end
-
-  def scalac_args
-    compile_task.instance_eval { @compiler }.send(:scalac_args)
-  end
-
-  it 'should set warnings option to false by default' do
-    compile_task.options.warnings.should be_false
-  end
-
-  it 'should set wranings option to true when running with --verbose option' do
-    verbose true
-    compile_task.options.warnings.should be_true
-  end
-
-  it 'should use -nowarn argument when warnings is false' do
-    compile_task.using(:warnings=>false)
-    scalac_args.should include('-nowarn') 
-  end
-
-  it 'should not use -nowarn argument when warnings is true' do
-    compile_task.using(:warnings=>true)
-    scalac_args.should_not include('-nowarn') 
-  end
-
-  it 'should not use -verbose argument by default' do
-    scalac_args.should_not include('-verbose') 
-  end
-
-  it 'should use -verbose argument when running with --trace option' do
-    trace true
-    scalac_args.should include('-verbose') 
-  end
-
-  it 'should set debug option to true by default' do
-    compile_task.options.debug.should be_true
-  end
-
-  it 'should set debug option to false based on Buildr.options' do
-    Buildr.options.debug = false
-    compile_task.options.debug.should be_false
-  end
-
-  it 'should set debug option to false based on debug environment variable' do
-    ENV['debug'] = 'no'
-    compile_task.options.debug.should be_false
-  end
-
-  it 'should set debug option to false based on DEBUG environment variable' do
-    ENV['DEBUG'] = 'no'
-    compile_task.options.debug.should be_false
-  end
-
-  it 'should use -g argument when debug option is true' do
-    compile_task.using(:debug=>true)
-    scalac_args.should include('-g')
-  end
-
-  it 'should not use -g argument when debug option is false' do
-    compile_task.using(:debug=>false)
-    scalac_args.should_not include('-g')
-  end
-
-  it 'should set deprecation option to false by default' do
-    compile_task.options.deprecation.should be_false
-  end
-
-  it 'should use -deprecation argument when deprecation is true' do
-    compile_task.using(:deprecation=>true)
-    scalac_args.should include('-deprecation')
-  end
-
-  it 'should not use -deprecation argument when deprecation is false' do
-    compile_task.using(:deprecation=>false)
-    scalac_args.should_not include('-deprecation')
-  end
-
-  it 'should set optimise option to false by default' do
-    compile_task.options.optimise.should be_false
-  end
-
-  it 'should use -optimise argument when deprecation is true' do
-    compile_task.using(:optimise=>true)
-    scalac_args.should include('-optimise')
-  end
-
-  it 'should not use -optimise argument when deprecation is false' do
-    compile_task.using(:optimise=>false)
-    scalac_args.should_not include('-optimise')
-  end
-
-  it 'should not set target option by default' do
-    compile_task.options.target.should be_nil
-    scalac_args.should_not include('-target')
-  end
-
-  it 'should use -target:xxx argument if target option set' do
-    compile_task.using(:target=>'1.5')
-    scalac_args.should include('-target:jvm-1.5')
-  end
-
-  it 'should not set other option by default' do
-    compile_task.options.other.should be_nil
-  end
-
-  it 'should pass other argument if other option is string' do
-    compile_task.using(:other=>'-unchecked')
-    scalac_args.should include('-unchecked')
-  end
-
-  it 'should pass other argument if other option is array' do
-    compile_task.using(:other=>['-unchecked', '-Xprint-types'])
-    scalac_args.should include('-unchecked', '-Xprint-types')
-  end
-
-  it 'should complain about options it doesn\'t know' do
-    write 'source/Test.scala', 'class Test {}'
-    compile_task.using(:unknown=>'option')
-    lambda { compile_task.from('source').invoke }.should raise_error(ArgumentError, /no such option/i)
-  end
-
-  it 'should inherit options from parent' do
-    define 'foo' do
-      compile.using(:warnings=>true, :debug=>true, :deprecation=>true, :target=>'1.4')
-      define 'bar' do
-        compile.using(:scalac)
-        compile.options.warnings.should be_true
-        compile.options.debug.should be_true
-        compile.options.deprecation.should be_true
-        compile.options.target.should eql('1.4')
-      end
-    end
-  end
-
-  after do
-    Buildr.options.debug = nil
-    ENV.delete "debug"
-    ENV.delete "DEBUG"
-  end
-end

data/spec/scala/tests_spec.rb

@@ -1,215 +0,0 @@
-# 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')
-
-# TODO's
-#  -test w/ Specs
-#  -test w/ ScalaCheck
-#  -failing test
-#  -test passing System props
-#  -test passing ENV variables
-#  -test exclude group
-#  -test include Suite's
-#  -test exclude Suite's
-
-
-describe Buildr::Scala::ScalaTest do
-  it 'should be the default test framework when test cases are in Scala' do
-    write 'src/test/scala/com/example/MySuite.scala', <<-SCALA
-      package com.example
-      import org.scalatest.FunSuite
-      class MySuite extends FunSuite {
-        test("addition") {
-          val sum = 1 + 1
-          assert(sum === 2)
-        }
-      }
-    SCALA
-    define 'foo'
-    project('foo').test.framework.should eql(:scalatest)
-  end
-
-  it 'should be picked if the test language is Scala' do
-    define 'foo' do
-      test.compile.using(:scalac)
-      test.framework.should eql(:scalatest)
-    end
-  end
-
-  it 'should include Scalatest dependencies' do
-    define('foo') { test.using(:scalatest) }
-    project('foo').test.compile.dependencies.should include(*artifacts(Scala::ScalaTest.dependencies))
-    project('foo').test.dependencies.should include(*artifacts(Scala::ScalaTest.dependencies))
-  end
-
-  it 'should include JMock dependencies' do
-    define('foo') { test.using(:scalatest) }
-    project('foo').test.compile.dependencies.should include(*artifacts(JMock.dependencies))
-    project('foo').test.dependencies.should include(*artifacts(JMock.dependencies))
-  end
-  
-  it 'should include Specs dependencies' do
-    define('foo') { test.using(:scalatest) }
-    project('foo').test.compile.dependencies.should include(*artifacts(Scala::ScalaSpecs.dependencies))
-    project('foo').test.dependencies.should include(*artifacts(Scala::ScalaSpecs.dependencies))
-  end
-
-  it 'should include ScalaCheck dependencies' do
-    define('foo') { test.using(:scalatest) }
-    project('foo').test.compile.dependencies.should include(*artifacts(Scala::ScalaCheck.dependencies))
-    project('foo').test.dependencies.should include(*artifacts(Scala::ScalaCheck.dependencies))
-  end
-
-  it 'should include public classes extending org.scalatest.FunSuite' do
-    write 'src/test/scala/com/example/MySuite.scala', <<-SCALA
-      package com.example
-      import org.scalatest.FunSuite
-      class MySuite extends FunSuite {
-        test("addition") {
-          val sum = 1 + 1
-          assert(sum === 2)
-        }
-      }
-    SCALA
-    define('foo').test.invoke
-    project('foo').test.tests.should include('com.example.MySuite')
-  end
-
-  it 'should ignore classes not extending org.scalatest.FunSuite' do
-    write 'src/test/scala/com/example/NotASuite.scala', <<-SCALA
-      package com.example
-      class Another {
-      }
-    SCALA
-    define('foo').test.invoke
-    project('foo').test.tests.should be_empty
-  end
-
-  it 'should ignore inner classes' do
-    write 'src/test/scala/com/example/InnerClassTest.scala', <<-SCALA
-      package com.example
-      import org.scalatest.FunSuite
-      class InnerClassTest extends FunSuite {
-        test("addition") {
-          val sum = 1 + 1
-          assert(sum === 2)
-        }
-        
-        class InnerSuite extends FunSuite {
-          test("addition") {
-            val sum = 1 + 1
-            assert(sum === 2)
-          }
-        }
-      }
-    SCALA
-    define('foo').test.invoke
-    project('foo').test.tests.should eql(['com.example.InnerClassTest'])
-  end
-
-  it 'should pass when ScalaTest test case passes' do
-    write 'src/test/scala/PassingSuite.scala', <<-SCALA
-      class PassingSuite extends org.scalatest.FunSuite {
-        test("addition") {
-          val sum = 1 + 1
-          assert(sum === 2)
-        }
-      }
-    SCALA
-    lambda { define('foo').test.invoke }.should_not raise_error
-  end
-
-  it 'should fail when ScalaTest test case fails' do
-    write 'src/test/scala/FailingSuite.scala', <<-SCALA
-      class FailingSuite extends org.scalatest.FunSuite {
-        test("failing") {
-          assert(false)
-        }
-      }
-    SCALA
-    lambda { define('foo').test.invoke }.should raise_error(RuntimeError, /Tests failed/) rescue nil
-  end
-
-  it 'should report failed test names' do
-    write 'src/test/scala/FailingSuite.scala', <<-SCALA
-      class FailingSuite extends org.scalatest.FunSuite {
-        test("failing") {
-          assert(false)
-        }
-      }
-    SCALA
-    define('foo').test.invoke rescue
-    project('foo').test.failed_tests.should include('FailingSuite')
-  end
-
-  it 'should report to reports/scalatest/TEST-TestSuiteName.txt' do
-    write 'src/test/scala/PassingSuite.scala', <<-SCALA
-      class PassingSuite extends org.scalatest.FunSuite {
-        test("passing") {
-          assert(true)
-        }
-      }
-    SCALA
-    define 'foo' do
-      test.report_to.should be(file('reports/scalatest'))
-    end
-    project('foo').test.invoke
-    project('foo').file('reports/scalatest/TEST-PassingSuite.txt').should exist
-  end
-
-  it 'should pass properties to Suite' do
-    write 'src/test/scala/PropertyTestSuite.scala', <<-SCALA
-      import org.scalatest._
-      class PropertyTestSuite extends FunSuite {
-        var properties = Map[String, Any]()
-        test("testProperty") {
-          assert(properties("name") === "value")
-        }
-        
-        protected override def runTests(testName: Option[String], reporter: Reporter, stopper: Stopper,
-                                        includes: Set[String], excludes: Set[String], properties: Map[String, Any]) {
-          this.properties = properties;                              
-          super.runTests(testName, reporter, stopper, includes, excludes, properties)
-        }
-      }
-    SCALA
-    define('foo').test.using :properties=>{ 'name'=>'value' }
-    project('foo').test.invoke
-  end
-
-  it 'should set current directory' do
-    mkpath 'baz'
-    expected = File.expand_path('baz')
-    expected.gsub!('/', '\\') if expected =~ /^[A-Z]:/ # Java returns back slashed paths for windows
-    write 'baz/src/test/scala/CurrentDirectoryTestSuite.scala', <<-SCALA
-      class CurrentDirectoryTestSuite extends org.scalatest.FunSuite {
-        test("testCurrentDirectory") {
-          assert("value" === System.getenv("NAME"))
-          assert(#{expected.inspect} === new java.io.File(".").getCanonicalPath())
-        }
-      }
-    SCALA
-    define 'bar' do
-      define 'baz' do
-        test.include 'CurrentDirectoryTest'
-      end
-    end
-    project('bar:baz').test.invoke
-  end
-
-end
-