hudson 0.2.4 → 0.2.5.pre2

data/README.md

@@ -0,0 +1,85 @@
+Hudson
+======
+
+Hudson is a sweet CI server. Hudson.rb makes it easy
+to run ruby builds by bundling all the ruby-centric plugins 
+(ruby, rake, git, github) and wrapping them in a super simple 
+executeable.
+
+Install
+=======
+
+    gem install hudson
+    gem install hudson --pre (bleeding edge)
+
+Example
+=======
+
+Hudson.rb is continuously tested using Hudson at [http://hudson.thefrontside.net/job/hudson.rb/](http://hudson.thefrontside.net/job/hudson.rb/).
+
+The `hudson` application allows you to see the projects/jobs and their statuses:
+
+    $ hudson list --host hudson.thefrontside.net --port 80
+    hudson.rb - http://hudson.thefrontside.net/job/hudson.rb/
+    TheRubyRacer - http://hudson.thefrontside.net/job/TheRubyRacer/
+    
+    # alternately use environment variables
+    $ HUDSON_HOST=hudson.thefrontside.net HUDSON_PORT=80 hudson list
+
+Usage
+=====
+
+To run Hudson server:
+
+    Usage: hudson server [HUDSON_HOME] [options]
+        -d, --daemon                     fork into background and run as daemon
+        -p, --port [3001]                run hudson on specified port 
+        -c, --control-port [3002]        set the shutdown/control port
+        -k, --kill                       send shutdown signal to control port
+        -v, --version                    show version information
+        -h, --help
+
+Note: HUDSON_HOME defaults to ~/.hudson
+
+To list Jobs/Projects on a Hudson server:
+
+    Usage: hudson list [project_path] [options]
+        -p, --port [3001]                find hudson on specified port
+            --host [localhost]           find hudson on specified host
+        -h, --help
+
+To add Project (create a Job) on a Hudson server:
+
+    Usage: hudson create [project_path] [options]
+        -n, --name [dir_name]            name of hudson job
+        -p, --port [3001]                find hudson on specified port
+            --host [localhost]           find hudson on specified host
+        -h, --help
+
+For all commands, if flags for `host:port` are not provided, it will use `$HUDSON_HOST` and `$HUDSON_PORT` if available.
+
+License
+=======
+
+(The MIT License)
+
+Copyright (c) 2010 Charles Lowell, cowboyd@thefrontside.net
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,120 @@
+$:.unshift('lib')
+require 'hudson'
+require 'rubygems'
+
+Gem::Specification.new do |s|
+  $gemspec = s
+  s.name = s.rubyforge_project =  "hudson"
+  s.version = Hudson::VERSION
+  s.summary = "Painless Continuous Integration with Hudson Server"
+  s.description = "A suite of utilities for bringing continous integration to your projects (not the other way around) with hudson CI"
+  s.email = ["cowboyd@thefrontside.net", "drnicwilliams@gmail.com"]
+  s.homepage = "http://github.com/cowboyd/hudson.rb"
+  s.authors = ["Charles Lowell", "Dr Nic Williams"]
+  s.executables = ["hudson"]
+  s.require_paths = ["lib"]
+  s.files = Rake::FileList.new("**/*").tap do |manifest|
+    manifest.exclude "tmp", "**/*.gem"
+  end.to_a
+  s.add_dependency("term-ansicolor", [">= 1.0.4"])
+  s.add_dependency("yajl-ruby", [">= 0.7.6"])
+  s.add_dependency("httparty", ["~> 0.5.2"])
+  s.add_dependency("builder", ["~> 2.1.2"])
+  s.add_dependency("thor", ["~> 0.13.6"])
+  s.add_dependency("hpricot")
+  s.add_development_dependency("cucumber", ["~> 0.7.3"])
+  s.add_development_dependency("rspec", ["~> 1.3.0"])
+  s.add_development_dependency("json", ["~>1.4.0"])
+end
+
+desc "Build gem"
+task :gem => :gemspec do
+  Gem::Builder.new($gemspec).build
+end
+
+desc "Build gemspec"
+task :gemspec => :clean do
+  File.open("#{$gemspec.name}.gemspec", "w") do |f|
+    f.write($gemspec.to_ruby)
+  end
+end
+
+desc "Clean up"
+task :clean do
+  sh "rm -rf *.gem"
+end
+
+namespace :cucumber do
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:wip, 'Run features that are being worked on') do |t|
+    t.cucumber_opts = "--tags @wip"
+  end
+  Cucumber::Rake::Task.new(:ok, 'Run features that should be working') do |t|
+    t.cucumber_opts = "--tags ~@wip"
+  end
+  task :all => [:ok, :wip]
+end
+
+desc 'Alias for cucumber:ok'
+task :cucumber => 'cucumber:ok'
+
+desc "Start test server; Run cucumber:ok; Kill Test Server;"
+task :default => ["hudson:server:killtest", "hudson:server:test"] do
+  require 'socket'
+  print "waiting for at most 30 seconds for the server to start"
+  tries = 1
+  begin
+    print "."; $stdout.flush
+    tries += 1
+    Net::HTTP.start("localhost", "3010") { |http| http.get('/') }
+    sleep(10)
+    puts ""
+    Rake::Task["cucumber:ok"].invoke
+  rescue Exception => e
+    if tries <= 15
+      sleep 2
+      retry
+    end
+    raise
+  ensure
+    Rake::Task["hudson:server:killtest"].tap do |task|
+      task.reenable
+      task.invoke
+    end
+  end
+end
+
+namespace :hudson do
+  namespace :server do
+    require 'fileutils'
+
+    desc "Run a server for tests"
+    task :test do
+      port = 3010
+      control = 3011
+
+      FileUtils.chdir(File.dirname(__FILE__)) do
+        logfile = File.join("/tmp", "test_hudson.log")
+        puts "Launching hudson test server at http://localhost:#{port}..."
+        puts "  output will be logged to #{logfile}"
+        `ruby bin/hudson server --home /tmp/test_hudson --port #{port} --control #{control} --daemon --logfile #{logfile}`
+      end
+    end
+
+    desc "Kill hudson test server if it is running."
+    task :killtest do
+      FileUtils.chdir(File.dirname(__FILE__)) do
+        puts "Killing any running server processes..."
+        `ruby bin/hudson server --control 3011 --kill 2>/dev/null`
+      end
+    end
+    
+    desc "Grab the latest hudson.war from hudson-ci.org"
+    task :getwar do
+      sh "cd lib/hudson && rm hudson.war && wget http://hudson-ci.org/latest/hudson.war"
+    end
+    
+  end
+end
+
+

data/bin/hudson

@@ -1,58 +1,7 @@
 #!/usr/bin/env ruby
+require 'rubygems'
+$:.unshift(File.expand_path(File.dirname(File.dirname(__FILE__) + "/../lib/hudson.rb")))
 require File.dirname(__FILE__) + '/../lib/hudson'
-require 'un'
-require 'optparse'
-
-
-options = {
-  :port => 3001,
-  :control => 3002,
-  :home => File.join(ENV['HOME'], '.hudson')
-}
-args = ARGV.dup
-
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: hudson [options] [HUDSON_HOME]"
-
-  opts.on("-d", "--daemon", "fork into background and run as daemon") do
-    options[:daemon] = true
-  end
-
-  opts.on("-p", "--port [3001]", "run hudson on specified port ") do |port|
-    options[:port] = port
-  end
-  
-  opts.on("-c", "--control-port [3002]", Integer, "set the shutdown/control port") do |port|
-    options[:control] = cport
-  end
-  
-  opts.on_tail("-k", "--kill", "send shutdown signal to control port") do
-    require 'socket'
-    TCPSocket.open("localhost", options[:control]) do |sock|
-      sock.write("0")
-    end
-    exit
-  end
-  
-  opts.on_tail("-v", "--version", "show version information") do
-    puts "#{Hudson::VERSION} (Hudson Server #{Hudson::HUDSON_VERSION})"
-    exit
-  end
-  opts.on_tail("-h", "--help") do
-    puts opts
-    exit
-  end
-  
-end
-opts.parse!(args)
-dir = args.shift || options[:home]
-FileUtils.mkdir_p dir
-FileUtils.cp_r Hudson::PLUGINS, dir
-ENV['HUDSON_HOME'] = dir
-cmd = ["java", "-jar", Hudson::WAR]
-cmd << "--httpPort=#{options[:port]}"
-cmd << "--controlPort=#{options[:control]}"
-cmd << "--daemon" if options[:daemon]
-puts cmd.join(" ")
-exec(*cmd)
+require 'hudson/cli'
 
+Hudson::CLI.start

data/features/create_jobs.feature

@@ -0,0 +1,22 @@
+Feature: Create jobs
+  In order to reduce cost of getting a new project up onto Hudson
+  As a project developer
+  I want to add a new project to Hudson as a job
+
+  Background:
+    Given I have a Hudson server running
+    And the Hudson server has no current jobs
+  
+  Scenario: Discover Ruby project, on git scm, and create job
+    Given I am in the "ruby" project folder
+    And the project uses "git" scm
+    When I run local executable "hudson" with arguments "create . --host localhost --port 3010"
+    Then I should see "Added project 'ruby' to Hudson."
+    Then I should see "http://localhost:3010/job/ruby/build"
+    When I run local executable "hudson" with arguments "list --host localhost --port 3010"
+    Then I should see "ruby"
+  
+  Scenario: Attempt to create project without scm
+    Given I am in the "ruby" project folder
+    When I run local executable "hudson" with arguments "create . --host localhost --port 3010"
+    Then I should see "Cannot determine project SCM. Currently supported:"

data/features/development.feature

@@ -0,0 +1,14 @@
+Feature: Development processes of hudson itself (rake tasks)
+
+  As a Newgem maintainer or contributor
+  I want rake tasks to maintain and release the gem
+  So that I can spend time on the tests and code, and not excessive time on maintenance processes
+    
+  Scenario: Generate RubyGem
+    Given this project is active project folder
+    When I invoke task "rake clean" so that I start with nothing
+    And I invoke task "rake gem"
+    Then file with name matching "hudson-*.gem" is created
+    And file with name matching "hudson.gemspec" is created
+    And the file "hudson.gemspec" is a valid gemspec
+

data/features/fixtures/projects/ruby/Rakefile

@@ -0,0 +1,4 @@
+desc "Default task runs tests"
+task :default do
+  puts "Tests ran successfully!"
+end

data/features/managing_remote_servers.feature

@@ -0,0 +1,31 @@
+@wip
+Feature: Managing remote servers
+  In order to reduce cost of referencing remote servers by explicit --host/--port options
+  As a user
+  I want a directory of remote servers I frequently use
+
+  Background:
+    Given I have a Hudson server running
+    And the Hudson server has no current jobs
+  
+  Scenario: No remote servers
+    When I run local executable "hudson" with arguments "list"
+    Then I should see "Either use --host or add remote servers."
+  
+  Scenario: Add a remote server
+    When I run local executable "hudson" with arguments "remotes add --host localhost --port 3010"
+    And I run local executable "hudson" with arguments "remotes add --host localhost --port 3011"
+    And I run local executable "hudson" with arguments "list"
+    Then I should not see "Either use --host or add remote servers."
+    And I should see "localhost:3010 -"
+    And I should see "No jobs"
+    And I should see "localhost:3011 - no connection"
+
+  Scenario: Add a remote server and access by abbreviation
+    When I run local executable "hudson" with arguments "remotes add --host localhost --port 3010"
+    When I run local executable "hudson" with arguments "remotes add --host another.server"
+    And I run local executable "hudson" with arguments "list --server local"
+    And I should see "localhost:3010 -"
+    And I should see "No jobs"
+    And I should not see "another.server"
+    

data/features/server.feature

@@ -0,0 +1,16 @@
+Feature: Running a Hudson Server
+  As a hudson server administrator
+  I want to be able to easily control a hudson server 
+  In order to spend my time on how the process operates, not how to start stop and control it. 
+  
+  Scenario: Start a Hudson Server
+    Given env variable $HOME set to project path "home"
+      And "home/.hudson" folder is deleted
+      And there is nothing listening on port 5001
+      And there is nothing listening on port 5002
+      And I cleanup any hudson processes with control port 5002
+    When I run hudson server with arguments "--port 5001 --control 5002 --daemon --logfile=server.log"
+    Then I should see a hudson server on port 5001
+      And folder "home/.hudson/server" is created
+      And folder "home/.hudson/server/javatmp" is created
+    

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,181 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to( project path |)"(.*)"/ do |env_var, path, value|
+  in_project_folder {
+    value = File.expand_path(value)
+  } unless path.empty?
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end
+
+Then /^the file "([^\"]*)" is a valid gemspec$/ do |filename|
+  spec = eval(File.read(filename))
+  spec.validate
+end

data/features/step_definitions/fixture_project_steps.rb

@@ -0,0 +1,8 @@
+Given /^I am in the "([^\"]*)" project folder$/ do |project|
+  project_folder = File.expand_path(File.dirname(__FILE__) + "/../fixtures/projects/#{project}")
+  in_tmp_folder do
+    FileUtils.cp_r(project_folder, project)
+    setup_active_project_folder(project)
+  end
+end
+

data/features/step_definitions/hudson_steps.rb

@@ -0,0 +1,71 @@
+Given /^I have a Hudson server running$/ do
+  unless ENV['HUDSON_PORT']
+    port = 3010
+    begin
+      res = Net::HTTP.start("localhost", port) { |http| http.get('/api/json') }
+    rescue Errno::ECONNREFUSED => e
+      puts "\n\n\nERROR: To run tests, launch hudson in test mode: 'rake hudson:server:test'\n\n\n"
+      exit
+    end
+    ENV['HUDSON_PORT'] = port.to_s
+    ENV['HUDSON_HOST'] = 'localhost'
+  end
+end
+
+Given /^the Hudson server has no current jobs$/ do
+  if port = ENV['HUDSON_PORT']
+    require "open-uri"
+    require "yajl"
+    hudson_info = Yajl::Parser.new.parse(open("http://localhost:#{ENV['HUDSON_PORT']}/api/json"))
+
+    hudson_info['jobs'].each do |job|
+      job_url = job['url']
+      res = Net::HTTP.start("localhost", port) { |http| http.post("#{job_url}doDelete/api/json", {}) }
+    end
+    hudson_info = Yajl::Parser.new.parse(open("http://localhost:#{ENV['HUDSON_PORT']}/api/json"))
+    hudson_info['jobs'].should == []
+  else
+    puts "WARNING: Run 'I have a Hudson server running' step first."
+  end
+end
+
+Given /^there is nothing listening on port (\d+)$/ do |port|
+  lambda {
+    TCPSocket.open("localhost", port) {}
+  }.should raise_error
+end
+
+Given /^I cleanup any hudson processes with control port (\d+)$/ do |port|
+  @hudson_cleanup << port
+end
+
+def try(times, interval = 1)
+  begin
+    times -= 1
+    return yield
+  rescue Exception => e
+    if times >= 0
+      sleep(interval)
+      retry
+    end
+    raise e
+  end
+end
+
+When /^I run hudson server with arguments "(.*)"/ do |arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin","hudson"))
+  in_project_folder do
+    system "ruby #{executable} server #{arguments} > #{@stdout} 2>#{@stdout}"
+  end
+end
+
+
+Then /^I should see a hudson server on port (\d+)$/ do |port|
+  require 'json'
+  try(15, 2) do
+    res = Net::HTTP.start("localhost", port) { |http| http.get('/api/json') }
+    JSON.parse(res.body)['nodeDescription'].should == "the master Hudson node"
+  end
+end
+

data/features/step_definitions/scm_steps.rb

@@ -0,0 +1,10 @@
+Given /^the project uses "git" scm$/ do
+  repo = "git://some.host/drnic/ruby.git"
+  in_project_folder do
+    %x[ git init ]
+    %x[ git add . ]
+    %x[ git commit -m "initial commit" ]
+    %x[ git remote add origin #{repo} ]
+  end
+end
+

data/features/support/common.rb

@@ -0,0 +1,29 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.expand_path(File.dirname(File.dirname(__FILE__) + "/../../lib/hudson.rb")))
+require File.dirname(__FILE__) + "/../../lib/hudson.rb"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end