aruba-jbb 0.2.2

data/features/running_ruby.feature

@@ -0,0 +1,76 @@
+@announce
+Feature: Running ruby
+  In order to test a Ruby-based CLI app
+  I want to have control over what Ruby version is used,
+  possibly using a different Ruby than the one I launch Cucumber with.
+
+  Scenario: Run with ruby 1.9.1
+    Given I am using rvm "1.9.1"
+    When I run "ruby -e 'puts RUBY_VERSION'"
+    Then the output should contain "ruby-1.9.1-p378"
+    And the output should not contain "rvm usage"
+
+  Scenario: Run with ruby JRuby
+    Given I am using rvm "jruby"
+    When I run "ruby -e 'puts JRUBY_VERSION'"
+    Then the output should contain "1.5.1"
+    And the output should not contain "rvm usage"
+
+  Scenario: Install gems with bundler
+    Given I am using rvm "1.9.1"
+    And I am using rvm gemset "a-new-gemset-where-no-gems-are-installed" with Gemfile:
+      """
+      source :gemcutter
+      gem 'diff-lcs', '1.1.2'
+      """
+    When I run "gem list"
+    Then the output should match:
+      """
+      bundler \(\d+\.+\d+\.+\d+\)
+      diff-lcs \(\d+\.+\d+\.+\d+\)
+      """
+
+  Scenario: Find the version of ruby 1.9.1
+    Given I am using rvm "1.9.1"
+    When I run "ruby --version"
+    Then the output should contain "1.9.1"
+
+  Scenario: Find the version of cucumber on ruby 1.9.1
+    Given I am using rvm "1.9.1"
+    When I run "cucumber --version"
+    Then the output should match /\d+\.+\d+\.+\d+/
+
+  Scenario: Use current ruby
+    When I run "ruby --version"
+    Then the output should contain the current Ruby version
+
+  Scenario: Use current ruby and a gem bin file
+    When I run "rake --version"
+    Then the output should contain "rake, version"
+
+  # I have trouble running rvm 1.8.7 in OS X Leopard, which is
+  # ruby-1.8.7-p249 (It segfaults rather often). However, a previous
+  # patchlevel of 1.8.7 runs fine for me: ruby-1.8.7-tv1_8_7_174
+  #
+  # In order to provide some level of flexibility (and readability)
+  # it should be possible to set up a mapping from a version specified
+  # in Gherkin to an *actual* version.
+  #
+  # In order to make this scenario pass you therefore need to install
+  # ruby-1.8.7-tv1_8_7_174 with rvm.
+  Scenario: Specify an alias for an rvm
+    Given I do have a file named "config/aruba-rvm.yml" with:
+      """
+      1.8.7: ruby-1.8.7-tv1_8_7_174
+      """
+      And I am using rvm "1.8.7"
+    When I run "ruby --version"
+    Then the output should contain "patchlevel 174"
+
+  # To verify this, make sure current rvm is *not* JRuby and run:
+  #
+  #   ~/.rvm/rubies/jruby-1.4.0/bin/jruby -S cucumber features/running_ruby.feature -n "launched Cucumber"
+  @jruby
+  Scenario: Don't use rvm, but default to same Ruby as the one that launched Cucumber
+    When I run "ruby -e 'puts JRUBY_VERSION if defined?(JRUBY_VERSION)'"
+    Then the output should contain the JRuby version

data/features/step_definitions/aruba_dev_steps.rb

@@ -0,0 +1,74 @@
+Before('@rebase-test') do
+  @rebase_test_dir = 'testdata'
+  @soft_link_target = File.join(current_dir.to_s, @rebase_test_dir)
+  # puts @soft_link_target
+  FileUtils.rm_rf(@rebase_test_dir)
+  FileUtils.mkdir_p(@rebase_test_dir)
+  rebase(@rebase_test_dir)
+  #File.open("delete_me.txt", 'w') { |f| f << "" }
+end
+
+
+After('@rebase-test') do
+  FileUtils.rm_rf(@rebase_test_dir)
+end
+
+
+When /create the cwd sub-directory named "([^\"]*)"/ do |dir|
+  FileUtils.mkdir_p(dir)
+end
+
+
+When /delete the cwd sub-directory named "([^\"]*)"/ do |dir|
+  FileUtils.rm_rf(dir)
+end
+
+
+When /^"([^\"]*)" should have a soft link in the aruba working directory$/ do \
+  |dir|
+  link = File.join(current_dir.to_s, dir)
+  File.symlink?(link).should be_true
+end
+
+
+When /the rebase-test before block conditions/ do
+  # Do nothing
+end
+
+
+When /soft links should exist in the aruba working directory/ do
+  File.symlink?(@soft_link_target).should be_true
+end
+
+
+When /do aruba (.*) step$/ do |aruba_step|
+  begin
+    When(aruba_step)
+  rescue => e
+    @aruba_exception = e
+  end
+end
+
+
+When /the clean_up api method should fail/ do
+  begin
+    clean_up
+    fail("clean_up api method did not raise error and should have")
+  rescue => @last_stderr
+  end
+end
+
+
+When /^the output should contain the JRuby version$/ do
+  Then %{the output should contain "#{JRUBY_VERSION}"}
+end
+
+
+When /^the output should contain the current Ruby version$/ do
+  Then %{the output should contain "#{RUBY_VERSION}"}
+end
+
+
+When /^aruba should fail with "([^\"]*)"$/ do |error_message|
+  @aruba_exception.message.should =~ compile_and_escape(error_message)
+end

data/features/support/env.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'aruba'
+require 'fileutils'
+
+begin
+  # rspec-2
+  require 'rspec/expectations'
+rescue LoadError
+  # rspec-1
+  require 'spec/expectations'
+end
+
+Before do
+  FileUtils.rm(Dir['config/*.yml'])
+end

data/lib/aruba/api.rb

@@ -0,0 +1,296 @@
+require 'tempfile'
+require 'rbconfig'
+
+module Aruba
+  module Api
+
+  def announce_or_puts(msg)
+    if(@puts)
+      puts(msg)
+    else
+      announce(msg)
+    end
+  end
+
+  def append_to_file(file_name, file_content)
+    in_current_dir do
+      File.open(file_name, 'a') { |f| f << file_content }
+    end
+  end
+
+  def aruba_working_dir
+    @aruba_working_dir
+  end
+
+  def x_ray(dir)
+    fail("In x_ray")
+  end
+
+  # This allows before hooks to set aruba's working directory
+  # relative to user's cwd
+  def aruba_working_dir_set(dir)
+    @aruba_working_dir = dir
+    dirs_init
+  end
+
+  # You can override the default working directory by setting
+  # the environment variable ARUBA_WORKING_DIR
+  ARUBA_WORKING_DIR_DEFAULT = 'tmp/aruba'   
+
+  def aruba_working_dir_init
+
+    if defined?(ENV[ARUBA_WORKING_DIR])
+      @aruba_working_dir = [ENV[ARUBA_WORKING_DIR]]
+    else
+      @aruba_working_dir ||= ['tmp/aruba']
+    end
+
+    dirs_init
+
+    clean_up
+
+    rebase_dirs_clear
+
+    if defined?(ENV[ARUBA_REBASE])
+      rebase(ENV[ARUBA_REBASE].split(%r{,|;\s*}))
+    end
+
+  end
+
+  def cd(dir)
+    dirs << dir
+    raise "#{current_dir} is not a directory." unless File.directory?(current_dir)
+  end
+  
+  def check_directory_presence(paths, expect_presence)
+    in_current_dir do
+      paths.each do |path|
+        if expect_presence
+          File.should be_directory(path)
+        else
+          File.should_not be_directory(path)
+        end
+      end
+    end
+  end
+
+  def check_file_content(file, partial_content, expect_match)
+    regexp = compile_and_escape(partial_content)
+    in_current_dir do
+      content = IO.read(file)
+      if expect_match
+        content.should =~ regexp
+      else
+        content.should_not =~ regexp
+      end
+    end
+  end
+
+  def check_file_presence(paths, expect_presence)
+    in_current_dir do
+      paths.each do |path|
+        if expect_presence
+          File.should be_file(path)
+        else
+          File.should_not be_file(path)
+        end
+      end
+    end
+  end
+
+  def clean_up(dir = current_dir)
+    check_tmp_dir = File.expand_path(dir)
+    if File.fnmatch('**/tmp/**',check_tmp_dir)
+      clean_up!
+    else
+      raise "#{check_tmp_dir} is outside the tmp subtree and may not be deleted."
+    end
+  end
+
+  def clean_up!(dir = current_dir)
+    FileUtils.rm_rf(dir)
+    _mkdir(dir)
+  end
+
+  def combined_output
+    @last_stdout.to_s + (@last_stderr.to_s == '' ? \
+      '' : "\n#{'-'*70}\n#{@last_stderr}")
+  end
+
+  def compile_and_escape(string)
+    Regexp.compile(Regexp.escape(string))
+  end
+
+  def create_dir(dir_name)
+    in_current_dir do
+      _mkdir(dir_name)
+    end
+  end
+
+  def create_file(file_name, file_content)
+    in_current_dir do
+      _mkdir(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+  
+  def create_rvm_gemset(rvm_gemset)
+    raise "You haven't specified what ruby version rvm should use." if @rvm_ruby_version.nil?
+    run "rvm --create #{@rvm_ruby_version}@#{rvm_gemset}"
+  end
+
+  def current_dir
+    File.join(*dirs)
+  end
+
+  def current_ruby
+    if @rvm_ruby_version
+      rvm_ruby_version_with_gemset = @rvm_gemset ? "#{@rvm_ruby_version}@#{@rvm_gemset}" : @rvm_ruby_version
+      "rvm #{rvm_ruby_version_with_gemset} ruby"
+    else
+      File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+    end
+  end
+  
+  def delete_rvm_gemset(rvm_gemset)
+    raise "You haven't specified what ruby version rvm should use." if @rvm_ruby_version.nil?
+    run "rvm --force gemset delete #{@rvm_ruby_version}@#{rvm_gemset}"
+  end
+
+  def detect_ruby(cmd)
+    if cmd =~ /^ruby\s/
+      cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+    else
+      cmd
+    end
+  end
+
+  COMMON_RUBY_SCRIPTS = /^(?:bundle|cucumber|gem|jeweler|rails|rake|rspec|spec)\s/
+
+  def detect_ruby_script(cmd)
+    if cmd =~ COMMON_RUBY_SCRIPTS
+      "ruby -S #{cmd}"
+    else
+      cmd
+    end
+  end
+
+  def pick_up
+    @pick_up
+  end
+
+  def dirs
+    @dirs ||= dirs_init
+  end
+
+  def dirs_init
+    @dirs = []
+    @dirs << aruba_working_dir
+  end
+
+  def in_current_dir(&block)
+    _mkdir(current_dir)
+    Dir.chdir(current_dir, &block)
+  end
+
+  def install_gems(gemfile)
+    create_file("Gemfile", gemfile)
+    if ENV['GOTGEMS'].nil?
+      run("gem install bundler")
+      run("bundle install")
+    end
+  end
+
+  def _mkdir(dir_name)
+    FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
+  end
+
+  def unescape(string)
+    eval(%{"#{string}"})
+  end
+
+  def use_rvm(rvm_ruby_version)
+    if File.exist?('config/aruba-rvm.yml')
+      @rvm_ruby_version = YAML.load_file('config/aruba-rvm.yml')[rvm_ruby_version] || rvm_ruby_version
+    else
+      @rvm_ruby_version = rvm_ruby_version
+    end
+  end
+
+  def rebase(dirs=nil)
+
+    rebase_dirs_add(dirs) if dirs
+
+    working_dir = File.expand_path(File.join(FileUtils.pwd, aruba_working_dir))
+
+    if rebase_dirs and File.fnmatch('**/tmp/**', working_dir)
+      rebase_dirs.each do |dir|
+        FileUtils.ln_s(File.join(user_working_dir, dir.to_s), 
+                       working_dir, :force => true)
+      end
+    else
+      raise "Aruba's working directory, #{working_dir}, \n" +
+            "is outside the tmp subtree and may not be rebased."
+    end
+
+  end
+
+  def rebase_dirs
+    @aruba_rebase_dirs
+  end
+
+  def rebase_dirs_add(dirs=nil)
+    return unless dirs
+    dirs = dirs.to_a.flatten
+    @aruba_rebase_dirs ||= []
+    @aruba_rebase_dirs = (@aruba_rebase_dirs + dirs).uniq
+  end
+
+  def rebase_dirs_clear
+    @aruba_rebase_dirs = []
+  end
+
+  def run(cmd, fail_on_error=true)
+    cmd = detect_ruby_script(cmd)
+    cmd = detect_ruby(cmd)
+
+    announce_or_puts("$ #{cmd}") if @announce_cmd
+
+    stderr_file = Tempfile.new('cucumber')
+    stderr_file.close
+    in_current_dir do
+      mode = RUBY_VERSION =~ /^1\.9/ ? {:external_encoding=>"UTF-8"} : 'r'
+      IO.popen("#{cmd} 2> #{stderr_file.path}", mode) do |io|
+        @last_stdout = io.read
+
+        announce_or_puts(@last_stdout) if @announce_stdout
+      end
+
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+
+    announce_or_puts(@last_stderr) if @announce_stderr
+
+    if(@last_exit_status != 0 && fail_on_error)
+      fail("Exit status was #{@last_exit_status}. Output:\n#{combined_output}")
+    end
+
+    @last_stderr
+  end
+
+  def use_rvm_gemset(rvm_gemset, empty_gemset)
+    @rvm_gemset = rvm_gemset
+    if empty_gemset && ENV['GOTGEMS'].nil?
+      delete_rvm_gemset(rvm_gemset)
+      create_rvm_gemset(rvm_gemset)
+    end
+  end
+
+  def user_working_dir
+    # This allows us to find the user's original working directory
+    @user_working_dir ||= FileUtils.pwd
+  end
+
+  end #api module
+end # aruba module

data/lib/aruba/cucumber_steps.rb

@@ -0,0 +1,234 @@
+require 'aruba/api'
+
+World(Aruba::Api)
+
+
+Before do 
+  aruba_working_dir_init
+end
+
+
+Before('@aruba-tmpdir') do
+  aruba_working_dir_init
+end
+
+
+Before('@no-aruba-tmpdir') do
+  puts aruba_working_dir
+  aruba_working_dir_set('./')
+  dirs_init
+end
+
+
+Before('@announce-cmd') do
+  @announce_cmd = true
+end
+
+
+Before('@announce-stdout') do
+  @announce_stdout = true
+end
+
+
+Before('@announce-stderr') do
+  @announce_stderr = true
+end
+
+
+Before('@announce') do
+  @announce_stdout = true
+  @announce_stderr = true
+  @announce_cmd = true
+end
+
+
+When /append to "([^\"]*)" with:$/ do |file_name, file_content|
+  append_to_file(file_name, file_content)
+end
+
+
+When /cd to "([^\"]*)"$/ do |dir|
+  cd(dir)
+end
+
+
+When /clean up the working directory/ do
+  clean_up
+end
+
+
+When /do have a directory named "([^\"]*)"$/ do |dir_name|
+  create_dir(dir_name)
+end
+
+
+When /do have a file named "([^\"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+
+When /do have an empty file named "([^\"]*)"$/ do |file_name|
+  create_file(file_name, "")
+end
+
+
+When /using rvm "([^\"]*)"$/ do |rvm_ruby_version|
+  use_rvm(rvm_ruby_version)
+end
+
+
+When /using( an empty)? rvm gemset "([^\"]*)"$/ do |empty_gemset, rvm_gemset|
+  use_rvm_gemset(rvm_gemset, empty_gemset)
+end
+
+
+When /using rvm gemset "([^\"]*)" with Gemfile:$/ do |rvm_gemset, gemfile|
+  use_rvm_gemset(rvm_gemset, true)
+  install_gems(gemfile)
+end
+
+
+When /rebase the directory named "([^\"]*)"$/ do |dir|
+  rebase(dir)
+end
+
+
+When /run "(.*)"$/ do |cmd|
+  run(unescape(cmd), false)
+end
+
+
+When /run "(.*)" with errors?$/ do |cmd|
+  run(unescape(cmd), false)
+end
+
+
+When /run "(.*)" without errors?$/ do |cmd|
+  run(unescape(cmd), true)
+end
+
+
+When /output should contain "([^\"]*)"$/ do |partial_output|
+  combined_output.should =~ compile_and_escape(partial_output)
+end
+
+
+When /output should not contain "([^\"]*)"$/ do |partial_output|
+  combined_output.should_not =~ compile_and_escape(partial_output)
+end
+
+
+When /output should contain:$/ do |partial_output|
+  combined_output.should =~ compile_and_escape(partial_output)
+end
+
+
+When /output should not contain:$/ do |partial_output|
+  combined_output.should_not =~ compile_and_escape(partial_output)
+end
+
+
+When /output should contain exactly "([^\"]*)"$/ do |exact_output|
+  combined_output.should == unescape(exact_output)
+end
+
+
+When /output should contain exactly:$/ do |exact_output|
+  combined_output.should == exact_output
+end
+
+
+# "the output should match" allows regex in the partial_output, if
+# you don't need regex, use "the output should contain" instead since
+# that way, you don't have to escape regex characters that
+# appear naturally in the output
+When /output should match \/([^\/]*)\/$/ do |partial_output|
+  combined_output.should =~ /#{partial_output}/
+end
+
+
+When /output should match:$/ do |partial_output|
+  combined_output.should =~ /#{partial_output}/m
+end
+
+
+When /exit status should be (\d+)$/ do |exit_status|
+  @last_exit_status.should == exit_status.to_i
+end
+
+
+When /exit status should not be (\d+)$/ do |exit_status|
+  @last_exit_status.should_not == exit_status.to_i
+end
+
+
+When /rebase the directory "()"$/ do |dir|
+  rebase(dir.to_a)
+end
+
+
+When /should (pass|fail) with:$/ do |pass_fail, partial_output|
+  When "output should contain:", partial_output
+  if pass_fail == 'pass'
+    @last_exit_status.should == 0
+  else
+    @last_exit_status.should_not == 0
+  end
+end
+
+
+When /stderr should be empty$/ do
+  @last_stderr.should == ""
+end
+
+
+When /stderr should contain "([^\"]*)"$/ do |partial_output|
+  @last_stderr.should =~ compile_and_escape(partial_output)
+end
+
+
+When /stdout should contain "([^\"]*)"$/ do |partial_output|
+  @last_stdout.should =~ compile_and_escape(partial_output)
+end
+
+
+When /stderr should not contain "([^\"]*)"$/ do |partial_output|
+  @last_stderr.should_not =~ compile_and_escape(partial_output)
+end
+
+
+When /stdout should not contain "([^\"]*)"$/ do |partial_output|
+  @last_stdout.should_not =~ compile_and_escape(partial_output)
+end
+
+
+When /following files? should exist:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, true)
+end
+
+
+When /following files? should not exist:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
+end
+
+
+When /following directories? should exist:$/ do |directories|
+  check_directory_presence(directories.raw.map{
+    |directory_row| directory_row[0]}, true)
+end
+
+
+When /following directories? should not exist:$/ do |directories|
+  check_file_presence(directories.raw.map{
+    |directory_row| directory_row[0]}, false)
+end
+
+
+When /file "([^\"]*)" should contain "([^\"]*)"$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end
+
+
+When /file "([^\"]*)" should not contain "([^\"]*)"$/ do |file, partial_content|
+  check_file_content(file, partial_content, false)
+end

data/lib/aruba.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber_steps'