rdmopensource-warbler 1.1.0

data/spec/sample/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'warbler'
+
+raise %{Error: detected running Warbler specs in a Rails app;
+Warbler specs are destructive to application directories.} if File.directory?("app")
+
+def silence(io = nil)
+  require 'stringio'
+  old_stdout = $stdout
+  old_stderr = $stderr
+  $stdout = io || StringIO.new
+  $stderr = io || StringIO.new
+  yield
+ensure
+  $stdout = old_stdout
+  $stderr = old_stderr
+end
+
+def capture(&block)
+  require 'stringio'
+  io = StringIO.new
+  silence(io, &block)
+  io.string
+end
+
+Spec::Runner.configure do |config|
+  config.after(:each) do
+    class << Object
+      public :remove_const
+    end
+    Object.remove_const("Rails") rescue nil
+    rm_rf "vendor"
+  end
+end

data/spec/warbler/application_spec.rb

@@ -0,0 +1,93 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Warbler::Application do
+  before :each do
+    verbose(false)
+    @pwd = Dir.getwd
+    Dir.chdir("spec/sample")
+    @argv = ARGV.dup
+    ARGV.clear
+    @app = Rake.application
+    rm_f "config/warble.rb"
+    @detection = Warbler.framework_detection
+    Warbler.framework_detection = false
+  end
+
+  after :each do
+    Rake.application = @app
+    Warbler.project_application = nil
+    Warbler.application = nil
+    Warbler.framework_detection = @detection
+    @argv.reverse.each {|a| ARGV.unshift a}
+    rm_rf FileList['vendor/plugins/warbler']
+    Dir.chdir(@pwd)
+  end
+
+  it "should be able to list its tasks" do
+    ARGV.unshift "-T"
+    output = capture do
+      Warbler::Application.new.run
+    end
+    output.should =~ /warble war\s/
+    output.should =~ /warble war:clean/
+    output.should =~ /warble war:debug/
+  end
+
+  it "should display the version" do
+    ARGV.unshift "version"
+    capture { Warbler::Application.new.run }.should =~ /#{Warbler::VERSION}/
+  end
+
+  it "should copy a fresh config file into place" do
+    File.exists?("config/warble.rb").should_not be_true
+    ARGV.unshift "config"
+    silence { Warbler::Application.new.run }
+    File.exists?("config/warble.rb").should be_true
+  end
+
+  it "should refuse to copy over an existing config file" do
+    touch "config/warble.rb"
+    ARGV.unshift "config"
+    capture { Warbler::Application.new.run }.should =~ /already exists/
+  end
+
+  it "should complain if the config directory is missing" do
+    begin
+      mv "config", "config-tmp"
+      ARGV.unshift "config"
+      capture { Warbler::Application.new.run }.should =~ /missing/
+    ensure
+      mv "config-tmp", "config"
+    end
+  end
+
+  it "should refuse to pluginize if the vendor/plugins/warbler directory exists" do
+    mkdir_p "vendor/plugins/warbler"
+    ARGV.unshift "pluginize"
+    silence { Warbler::Application.new.run }
+    File.exist?("vendor/plugins/warbler/tasks/warbler.rake").should_not be_true
+  end
+
+  it "should define a pluginize task for adding the tasks to a Rails application" do
+    ARGV.unshift "pluginize"
+    Warbler::Application.new.run
+    File.exist?("vendor/plugins/warbler/tasks/warbler.rake").should be_true
+  end
+
+  it "should provide a means to load the project Rakefile" do
+    Warbler::Application.new.load_project_rakefile
+  end
+
+  it "should define a gemjar task for setting up gem packaging inside a jar" do
+    ARGV.unshift "gemjar"
+    Warbler::Application.new.run
+    Rake::Task['war:jar'].prerequisites.should include('war:make_gemjar')
+  end
+end

data/spec/warbler/config_spec.rb

@@ -0,0 +1,112 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Warbler::Config do
+  before :each do
+    verbose(false)
+  end
+
+  it "should have suitable default values" do
+    config = Warbler::Config.new
+    config.dirs.should include(*Warbler::Config::TOP_DIRS.select{|d| File.directory?(d)})
+    config.includes.should be_empty
+    config.java_libs.should_not be_empty
+    config.war_name.size.should > 0
+    config.webxml.should be_kind_of(OpenStruct)
+    config.pathmaps.should be_kind_of(OpenStruct)
+    config.pathmaps.public_html.should == ["%{public/,}p"]
+  end
+
+  it "should allow configuration through an initializer block" do
+    config = Warbler::Config.new do |c|
+      c.war_name = "mywar"
+    end
+    config.war_name.should == "mywar"
+  end
+
+  it "should allow gems to be added/changed with =, +=, -=, <<" do
+    config = Warbler::Config.new do |c|
+      c.gems += ["activerecord-jdbc-adapter"]
+      c.gems -= ["rails"]
+      c.gems << "tzinfo"
+      c.gems = ["camping"]
+    end
+  end
+
+  it "should exclude log files by default" do
+    mkdir_p "vendor"
+    touch "vendor/test.log"
+    config = Warbler::Config.new
+    config.exclude_logs.should == true
+    config.excludes.include?("vendor/test.log").should == true
+  end
+
+  it "should include log files if exclude_logs is false" do
+    mkdir_p "vendor"
+    touch "vendor/test.log"
+    config = Warbler::Config.new {|c| c.exclude_logs = false }
+    config.exclude_logs.should == false
+    config.excludes.include?("vendor/test.log").should == false
+  end
+
+  it "should exclude Warbler itself when run as a plugin" do
+    config = Warbler::Config.new
+    config.excludes.include?("vendor/plugins/warbler").should == false
+    config = Warbler::Config.new File.join(Dir.getwd, "vendor", "plugins", "warbler")
+    config.excludes.include?("vendor/plugins/warbler").should == true
+  end
+
+  it "should generate context parameters from the webxml openstruct" do
+    config = Warbler::Config.new
+    config.webxml.a.b.c = "123"
+    config.webxml.com.example.config = "blah"
+    config.webxml.rails.env = 'staging'
+    config.webxml.jruby.min.runtimes = 2
+    config.webxml.jruby.max.runtimes = 4
+    config.webxml['org']['jruby']['rack'] = "rails"
+    params = config.webxml.context_params
+    params.should have_key('a.b.c')
+    params.should have_key('rails.env')
+    params.should have_key('jruby.min.runtimes')
+    params.should have_key('jruby.max.runtimes')
+    params['a.b.c'].should == "123"
+    params['com.example.config'].should == "blah"
+    params['rails.env'].should == "staging"
+    params['jruby.min.runtimes'].should == "2"
+    params['jruby.max.runtimes'].should == "4"
+    params['org.jruby.rack'].should == "rails"
+  end
+
+  it "should determine the context listener from the webxml.booter parameter" do
+    config = Warbler::Config.new
+    config.webxml.booter = :rack
+    config.webxml.servlet_context_listener.should == "org.jruby.rack.RackServletContextListener"
+    config = Warbler::Config.new
+    config.webxml.booter = :merb
+    config.webxml.servlet_context_listener.should == "org.jruby.rack.merb.MerbServletContextListener"
+    config = Warbler::Config.new
+    config.webxml.servlet_context_listener.should == "org.jruby.rack.rails.RailsServletContextListener"
+  end
+
+  it "should not include ignored webxml keys in the context params hash" do
+    Warbler::Config.new.webxml.context_params.should_not have_key('ignored')
+    Warbler::Config.new.webxml.context_params.should_not have_key('jndi')
+    Warbler::Config.new.webxml.context_params.should_not have_key('booter')
+  end
+
+  it "should have a helpful string representation for an empty key" do
+    Warbler::Config.new.webxml.missing_key.to_s.should =~ /No value for 'missing_key' found/
+  end
+
+  it "should HTML-escape all webxml keys and values" do
+    config = Warbler::Config.new
+    config.webxml.a["b&"].c = "123<hi>456"
+    config.webxml.context_params['a.b&amp;.c'].should == "123&lt;hi&gt;456"
+  end
+end

data/spec/warbler/gems_spec.rb

@@ -0,0 +1,40 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Warbler::Gems do
+  it "should accept a hash for initialization" do
+    gems = Warbler::Gems.new({"actionpack" => "1.2.3"})
+    gems.should have_key("actionpack")
+    gems["actionpack"].should == "1.2.3"
+  end
+
+  it "should accept an array for initialization" do
+    gems = Warbler::Gems.new ["activerecord"]
+    gems.should have_key("activerecord")
+  end
+
+  it "should allow gems with a version" do
+    gems = Warbler::Gems.new
+    gems["actionpack"] = "> 1.2.3"
+    gems["actionpack"].should == "> 1.2.3"
+  end
+
+  it "should allow gems without an explicit version" do
+    gems = Warbler::Gems.new
+    gems << "actionpack"
+    gems.should have_key("actionpack")
+  end
+
+  it "should allow to add gems" do
+    gems = Warbler::Gems.new
+    gems << "rails"
+    gems += ["activerecord-jdbcmysql-adapter", "jdbc-mysql", "jruby-openssl"]
+    ["rails", "activerecord-jdbcmysql-adapter", "jdbc-mysql", "jruby-openssl"].each {|g| gems.should have_key(g)}
+  end
+end

data/spec/warbler/task_spec.rb

@@ -0,0 +1,146 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Warbler::Task do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    verbose(false)
+    @pwd = Dir.getwd
+    Dir.chdir("spec/sample")
+    mkdir_p "log"
+    touch "log/test.log"
+    @config = Warbler::Config.new do |config|
+      config.war_name = "warbler"
+      config.gems = ["rake"]
+      config.webxml.jruby.max.runtimes = 5
+    end
+    @task = Warbler::Task.new "warble", @config
+  end
+
+  after(:each) do
+    Rake::Task["warble:clean"].invoke
+    rm_rf "log"
+    rm_f FileList["config.ru", "*web.xml", "config/web.xml*", "config/warble.rb",
+                  "config/special.txt", "config/link.txt", "tmp/gems.jar",
+                  "file.txt", 'Gemfile', 'lib/rakelib']
+    Dir.chdir(@pwd)
+  end
+
+  it "should define a clean task for removing the war file" do
+    war_file = "#{@config.war_name}.war"
+    touch war_file
+    Rake::Task["warble:clean"].invoke
+    File.exist?(war_file).should == false
+  end
+
+  it "should define a make_gemjar task for storing gems in a jar file" do
+    silence { Rake::Task["warble:make_gemjar"].invoke }
+    File.exist?("tmp/gems.jar").should == true
+    @task.war.files.keys.should_not include(%r{WEB-INF\/gems})
+    @task.war.files.keys.should include("WEB-INF/lib/gems.jar")
+  end
+
+  it "should define a war task for bundling up everything" do
+    files_ran = false; task "warble:files" do; files_ran = true; end
+    jar_ran = false; task "warble:jar" do; jar_ran = true; end
+    silence { Rake::Task["warble"].invoke }
+    files_ran.should == true
+    jar_ran.should == true
+  end
+
+  it "should define a jar task for creating the .war" do
+    touch "file.txt"
+    @task.war.files["file.txt"] = "file.txt"
+    silence { Rake::Task["warble:jar"].invoke }
+    File.exist?("#{@config.war_name}.war").should == true
+  end
+
+  it "should invoke feature tasks configured in config.features" do
+    @config.features << "gemjar"
+    silence { Rake::Task["warble"].invoke }
+    @task.war.files.keys.should include("WEB-INF/lib/gems.jar")
+  end
+
+  it "should warn and skip unknown features configured in config.features" do
+    @config.features << "bogus"
+    capture { Rake::Task["warble"].invoke }.should =~ /unknown feature `bogus'/
+  end
+
+  it "should define an executable task for embedding a server in the war file" do
+    silence { Rake::Task["warble:executable"].invoke }
+    @task.war.files.keys.should include('WEB-INF/winstone.jar')
+  end
+
+  it "should be able to define all tasks successfully" do
+    Warbler::Task.new "warble", @config
+  end
+
+  it "should compile any ruby files specified" do
+    @config.compiled_ruby_files = FileList["app/helpers/application_helper.rb"]
+    silence { Rake::Task["warble"].invoke }
+
+    java_class_magic_number = [0xCA,0xFE,0xBA,0xBE].map { |magic_char| magic_char.chr }.join
+
+    Zip::ZipFile.open("#{@config.war_name}.war") do |zf|
+      java_class_header     = zf.get_input_stream('WEB-INF/app/helpers/application_helper.class') {|io| io.read }[0..3]
+      ruby_class_definition = zf.get_input_stream('WEB-INF/app/helpers/application_helper.rb') {|io| io.read }
+
+      java_class_header.should == java_class_magic_number
+      ruby_class_definition.should == %{require __FILE__.sub(/.rb$/, '.class')}
+    end
+  end
+
+  it "should process symlinks by storing a file in the archive that has the same contents as the source" do
+    File.open("config/special.txt", "wb") {|f| f << "special"}
+    Dir.chdir("config") { ln_s "special.txt", "link.txt" }
+    silence { Rake::Task["warble"].invoke }
+    Zip::ZipFile.open("#{@config.war_name}.war") do |zf|
+      special = zf.get_input_stream('WEB-INF/config/special.txt') {|io| io.read }
+      link = zf.get_input_stream('WEB-INF/config/link.txt') {|io| io.read }
+      link.should == special
+    end
+  end
+
+  it "should process directory symlinks by copying the whole subdirectory" do
+    Dir.chdir("lib") { ln_s "tasks", "rakelib" }
+    silence { Rake::Task["warble"].invoke }
+    Zip::ZipFile.open("#{@config.war_name}.war") do |zf|
+      zf.find_entry("WEB-INF/lib/tasks/utils.rake").should_not be_nil
+      zf.find_entry("WEB-INF/lib/rakelib/").should_not be_nil
+      zf.find_entry("WEB-INF/lib/rakelib/utils.rake").should_not be_nil if defined?(JRUBY_VERSION)
+    end
+  end
+
+  it "should use a Bundler Gemfile to include gems" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @config.bundler = true
+    @config.send(:detect_bundler_gems)
+    silence { Rake::Task["warble"].invoke }
+    Zip::ZipFile.open("#{@config.war_name}.war") do |zf|
+      rspec_version = @config.gems.keys.detect {|k| k.name == 'rspec'}.version
+      zf.find_entry("WEB-INF/gems/specifications/rspec-#{rspec_version}.gemspec").should_not be_nil
+    end
+  end
+end
+
+describe "Debug targets" do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    verbose(false)
+    silence { Warbler::Task.new :war, Object.new }
+  end
+
+  it "should print out lists of files" do
+    capture { Rake::Task["war:debug:includes"].invoke }.should =~ /include/
+    capture { Rake::Task["war:debug:excludes"].invoke }.should =~ /exclude/
+    capture { Rake::Task["war:debug"].invoke }.should =~ /Config/
+  end
+end

data/spec/warbler/war_spec.rb

@@ -0,0 +1,441 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Warbler::War do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    verbose(false)
+    @pwd = Dir.getwd
+    Dir.chdir("spec/sample")
+    mkdir_p "log"
+    touch "log/test.log"
+    @config = Warbler::Config.new do |config|
+      config.war_name = "warbler"
+      config.gems = ["rake"]
+      config.webxml.jruby.max.runtimes = 5
+    end
+    @war = Warbler::War.new
+  end
+
+  after(:each) do
+    rm_rf "log"
+    rm_rf ".bundle"
+    rm_f FileList["*.war", "config.ru", "*web.xml*", "config/web.xml*",
+                  "config/warble.rb", "file.txt", 'manifest', 'Gemfile*']
+    Dir.chdir(@pwd)
+  end
+
+  def file_list(regex)
+    @war.files.keys.select {|f| f =~ regex }
+  end
+
+  it "should collect files in public" do
+    @war.apply(@config)
+    file_list(%r{^index\.html}).should_not be_empty
+  end
+
+  it "should collect gem files" do
+    @config.gems << "rake"
+    @war.apply(@config)
+    file_list(%r{WEB-INF/gems/gems/rake.*/lib/rake.rb}).should_not be_empty
+    file_list(%r{WEB-INF/gems/specifications/rake.*\.gemspec}).should_not be_empty
+  end
+
+  it "should not include log files by default" do
+    @war.apply(@config)
+    file_list(%r{WEB-INF/log}).should_not be_empty
+    file_list(%r{WEB-INF/log/.*\.log}).should be_empty
+  end
+
+  def expand_webxml
+    @war.apply(@config)
+    @war.files.should include("WEB-INF/web.xml")
+    require 'rexml/document'
+    REXML::Document.new(@war.files["WEB-INF/web.xml"]).root.elements
+  end
+
+  it "should create a web.xml file" do
+    elements = expand_webxml
+    elements.to_a(
+      "context-param/param-name[text()='jruby.max.runtimes']"
+      ).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='jruby.max.runtimes']/../param-value"
+      ).first.text.should == "5"
+  end
+
+  it "should include custom context parameters in web.xml" do
+    @config.webxml.some.custom.config = "myconfig"
+    elements = expand_webxml
+    elements.to_a(
+      "context-param/param-name[text()='some.custom.config']"
+      ).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='some.custom.config']/../param-value"
+      ).first.text.should == "myconfig"
+  end
+
+  it "should allow one jndi resource to be included" do
+    @config.webxml.jndi = 'jndi/rails'
+    elements = expand_webxml
+    elements.to_a(
+      "resource-ref/res-ref-name[text()='jndi/rails']"
+      ).should_not be_empty
+  end
+
+  it "should allow multiple jndi resources to be included" do
+    @config.webxml.jndi = ['jndi/rails1', 'jndi/rails2']
+    elements = expand_webxml
+    elements.to_a(
+      "resource-ref/res-ref-name[text()='jndi/rails1']"
+      ).should_not be_empty
+    elements.to_a(
+      "resource-ref/res-ref-name[text()='jndi/rails2']"
+      ).should_not be_empty
+  end
+
+  it "should not include any ignored context parameters" do
+    @config.webxml.foo = "bar"
+    @config.webxml.ignored << "foo"
+    elements = expand_webxml
+    elements.to_a(
+      "context-param/param-name[text()='foo']"
+      ).should be_empty
+    elements.to_a(
+      "context-param/param-name[text()='ignored']"
+      ).should be_empty
+    elements.to_a(
+      "context-param/param-name[text()='jndi']"
+      ).should be_empty
+  end
+
+  it "should use a config/web.xml if it exists" do
+    mkdir_p "config"
+    touch "config/web.xml"
+    @war.apply(Warbler::Config.new)
+    @war.files["WEB-INF/web.xml"].should == "config/web.xml"
+  end
+
+  it "should use a config/web.xml.erb if it exists" do
+    mkdir_p "config"
+    File.open("config/web.xml.erb", "w") {|f| f << "Hi <%= webxml.public.root %>" }
+    @war.apply(Warbler::Config.new)
+    @war.files["WEB-INF/web.xml"].should_not be_nil
+    @war.files["WEB-INF/web.xml"].read.should == "Hi /"
+  end
+
+  it "should collect java libraries" do
+    @war.apply(@config)
+    file_list(%r{WEB-INF/lib/jruby-.*\.jar$}).should_not be_empty
+  end
+
+  it "should collect application files" do
+    @war.apply(@config)
+    file_list(%r{WEB-INF/app$}).should_not be_empty
+    file_list(%r{WEB-INF/config$}).should_not be_empty
+    file_list(%r{WEB-INF/lib$}).should_not be_empty
+  end
+
+  it "should accept an autodeploy directory where the war should be created" do
+    require 'tmpdir'
+    @config.autodeploy_dir = Dir::tmpdir
+    touch "file.txt"
+    @war.files["file.txt"] = "file.txt"
+    silence { @war.create(@config) }
+    File.exist?(File.join("#{Dir::tmpdir}","warbler.war")).should == true
+  end
+
+  it "should accept a custom manifest file" do
+    touch 'manifest'
+    @config.manifest_file = 'manifest'
+    @war.apply(@config)
+    @war.files['META-INF/MANIFEST.MF'].should == "manifest"
+  end
+
+  it "should not add a manifest if one already exists" do
+    @war.files['META-INF/MANIFEST.MF'] = 'manifest'
+    @war.add_manifest(@config)
+    @war.files['META-INF/MANIFEST.MF'].should == "manifest"
+  end
+
+  it "should be able to exclude files from the .war" do
+    @config.excludes += FileList['lib/tasks/utils.rake']
+    @war.apply(@config)
+    file_list(%r{lib/tasks/utils.rake}).should be_empty
+  end
+
+  it "should read configuration from #{Warbler::Config::FILE}" do
+    mkdir_p "config"
+    File.open(Warbler::Config::FILE, "w") do |dest|
+      contents =
+        File.open("#{Warbler::WARBLER_HOME}/warble.rb") do |src|
+          src.read
+        end
+      dest << contents.sub(/# config\.war_name/, 'config.war_name'
+        ).sub(/# config.gems << "tzinfo"/, 'config.gems = []')
+    end
+    t = Warbler::Task.new "warble"
+    t.config.war_name.should == "mywar"
+  end
+
+  it "should fail if a gem is requested that is not installed" do
+    @config.gems = ["nonexistent-gem"]
+    lambda {
+      Warbler::Task.new "warble", @config
+      @war.apply(@config)
+    }.should raise_error
+  end
+
+  it "should allow specification of dependency by Gem::Dependency" do
+    spec = mock "gem spec"
+    spec.stub!(:full_name).and_return "hpricot-0.6.157"
+    spec.stub!(:full_gem_path).and_return "hpricot-0.6.157"
+    spec.stub!(:loaded_from).and_return "hpricot.gemspec"
+    spec.stub!(:files).and_return ["Rakefile"]
+    spec.stub!(:dependencies).and_return []
+    Gem.source_index.should_receive(:search).and_return do |gem|
+      gem.name.should == "hpricot"
+      [spec]
+    end
+    @config.gems = [Gem::Dependency.new("hpricot", "> 0.6")]
+    @war.apply(@config)
+  end
+
+  it "should copy loose java classes to WEB-INF/classes" do
+    @config.java_classes = FileList["Rakefile"]
+    @war.apply(@config)
+    file_list(%r{WEB-INF/classes/Rakefile$}).should_not be_empty
+  end
+
+  def mock_rails_module
+    rails = Module.new
+    Object.const_set("Rails", rails)
+    version = Module.new
+    rails.const_set("VERSION", version)
+    version.const_set("STRING", "2.1.0")
+    rails
+  end
+
+  def mock_merb_module
+    merb = Module.new
+    silence { Object.const_set("Merb", merb) }
+    boot_loader = Module.new
+    merb.const_set("BootLoader", boot_loader)
+    merb.const_set("VERSION", "1.0")
+    dependencies = Class.new do
+      @@dependencies = []
+      def self.dependencies
+        @@dependencies
+      end
+      def self.dependencies=(deps)
+        @@dependencies = deps
+      end
+    end
+    boot_loader.const_set("Dependencies", dependencies)
+    dependencies
+  end
+
+  it "should auto-detect a Rails application" do
+    task :environment do
+      mock_rails_module
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rails
+    @config.gems["rails"].should == "2.1.0"
+  end
+
+  it "should provide Rails gems by default, unless vendor/rails is present" do
+    rails = nil
+    task :environment do
+      rails = mock_rails_module
+    end
+
+    config = Warbler::Config.new
+    config.gems.should have_key("rails")
+
+    mkdir_p "vendor/rails"
+    config = Warbler::Config.new
+    config.gems.should be_empty
+
+    rm_rf "vendor/rails"
+    rails.stub!(:vendor_rails?).and_return true
+    config = Warbler::Config.new
+    config.gems.should be_empty
+  end
+
+  it "should not try to autodetect frameworks when Warbler.framework_detection is false" do
+    begin
+      Warbler.framework_detection = false
+      task :environment
+      config = Warbler::Config.new
+      config.webxml.booter.should_not == :rails
+      t = Rake::Task['environment']
+      class << t; public :instance_variable_get; end
+      t.instance_variable_get("@already_invoked").should == false
+    ensure
+      Warbler.framework_detection = true
+    end
+  end
+
+  it "should auto-detect a Merb application" do
+    task :merb_env do
+      mock_merb_module
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :merb
+    @config.gems.keys.should_not include("rails")
+  end
+
+  it "should auto-detect a Rack application with a config.ru file" do
+    rackup = "run Proc.new {|env| [200, {}, ['Hello World']]}"
+    File.open("config.ru", "w") {|f| f << rackup }
+    @config = Warbler::Config.new
+    @war.apply(@config)
+    @war.files['WEB-INF/config.ru'].should == 'config.ru'
+  end
+
+  it "should automatically add Rails.configuration.gems to the list of gems" do
+    task :environment do
+      rails = mock_rails_module
+      config = mock "config"
+      rails.stub!(:configuration).and_return(config)
+      gem = mock "gem"
+      gem.stub!(:name).and_return "hpricot"
+      gem.stub!(:requirement).and_return Gem::Requirement.new("=0.6")
+      config.stub!(:gems).and_return [gem]
+    end
+
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rails
+    @config.gems.keys.should include(Gem::Dependency.new("hpricot", Gem::Requirement.new("=0.6")))
+  end
+
+  it "should automatically add Merb::BootLoader::Dependencies.dependencies to the list of gems" do
+    task :merb_env do
+      deps = mock_merb_module
+      deps.dependencies = [Gem::Dependency.new("merb-core", ">= 1.0.6.1")]
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :merb
+    @config.gems.keys.should include(Gem::Dependency.new("merb-core", ">= 1.0.6.1"))
+  end
+
+  it "should skip Merb development dependencies" do
+    task :merb_env do
+      deps = mock_merb_module
+      deps.dependencies = [Gem::Dependency.new("rake", "= #{RAKEVERSION}", :development)]
+    end
+    @war.apply(Warbler::Config.new)
+    file_list(/rake-#{RAKEVERSION}/).should be_empty
+  end
+
+  it "should warn about using Merb < 1.0" do
+    task :merb_env do
+      silence { Object.const_set("Merb", Module.new) }
+    end
+    @config = silence { Warbler::Config.new }
+    @config.webxml.booter.should == :merb
+  end
+
+  it "should set the jruby max runtimes to 1 when MT Rails is detected" do
+    task :environment do
+      rails = mock_rails_module
+      config = mock "config"
+      rails.stub!(:configuration).and_return(config)
+      config.stub!(:threadsafe!)
+      config.should_receive(:allow_concurrency).and_return true
+      config.should_receive(:preload_frameworks).and_return true
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rails
+    @config.webxml.jruby.max.runtimes.should == 1
+  end
+
+  it "should skip directories that don't exist in config.dirs and print a warning" do
+    @config.dirs = %w(lib notexist)
+    silence { @war.apply(@config) }
+    file_list(%r{WEB-INF/lib}).should_not be_empty
+    file_list(%r{WEB-INF/notexist}).should be_empty
+  end
+
+  it "should write gems to location specified by gem_path" do
+    @config = Warbler::Config.new {|c| c.gem_path = "/WEB-INF/jewels"; c.gems << 'rake' }
+    elements = expand_webxml
+    file_list(%r{WEB-INF/jewels}).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='gem.path']"
+      ).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='gem.path']/../param-value"
+      ).first.text.should == "/WEB-INF/jewels"
+
+  end
+
+  it "should detect a Bundler Gemfile and process only its gems" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @war.apply(Warbler::Config.new {|c| c.gems << "rake"})
+    file_list(%r{WEB-INF/Gemfile}).should_not be_empty
+    file_list(%r{WEB-INF/gems/specifications/rspec}).should_not be_empty
+    file_list(%r{WEB-INF/gems/specifications/rake}).should be_empty
+  end
+
+  it "should write a Bundler environment file into the war" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @war.apply(Warbler::Config.new)
+    file_list(%r{WEB-INF/Gemfile}).should_not be_empty
+    file_list(%r{WEB-INF/Gemfile.lock}).should be_empty
+    file_list(%r{WEB-INF/\.bundle/environment\.rb}).should be_empty
+  end
+
+  it "should only include Bundler lockfiles if Gemfile.lock exists" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    `ruby -S bundle lock`
+    @war.apply(Warbler::Config.new)
+    file_list(%r{WEB-INF/Gemfile.lock}).should_not be_empty
+    file_list(%r{WEB-INF/\.bundle/environment\.rb}).should_not be_empty
+  end
+
+  it "should allow overriding of the gem path when using Bundler" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @war.apply(Warbler::Config.new {|c| c.gem_path = '/WEB-INF/jewels' })
+    file_list(%r{WEB-INF/jewels/specifications/rspec}).should_not be_empty
+    IO.readlines(".bundle/war-environment.rb").grep(/rspec/).last.should =~ %r{jewels/specifications}m
+  end
+
+  it "should not let the framework load Bundler from the locked environment" do
+    task :environment do
+      File.exist?('.bundle/environment.rb').should_not be_true
+      mock_rails_module
+    end
+
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    `ruby -S bundle lock`
+    File.exist?('.bundle/environment.rb').should be_true
+    @war.apply(Warbler::Config.new)
+    hash = eval("[" + IO.readlines(".bundle/environment.rb").grep(/rspec/).last + "]").first
+    hash[:load_paths].each {|p| File.exist?(p).should be_true }
+  end
+
+  it "should allow adding additional WEB-INF files via config.webinf_files" do
+    File.open("myserver-web.xml", "w") do |f|
+      f << "<web-app></web-app>"
+    end
+    @war.apply(Warbler::Config.new {|c| c.webinf_files = FileList['myserver-web.xml'] })
+    file_list(%r{WEB-INF/myserver-web.xml}).should_not be_empty
+  end
+
+  it "should allow expanding of additional WEB-INF files via config.webinf_files" do
+    File.open("myserver-web.xml.erb", "w") do |f|
+      f << "<web-app><%= webxml.rails.env %></web-app>"
+    end
+    @war.apply(Warbler::Config.new {|c| c.webinf_files = FileList['myserver-web.xml.erb'] })
+    file_list(%r{WEB-INF/myserver-web.xml}).should_not be_empty
+    @war.files['WEB-INF/myserver-web.xml'].read.should =~ /web-app.*production/
+  end
+end