pickled_aruba 0.1.0

data/features/step_definitions/pickled_aruba_dev_steps.rb

@@ -0,0 +1,15 @@
+When /^I do pickled_aruba (.*)$/ do |aruba_step|
+  begin
+    When(aruba_step)
+  rescue => e
+    @aruba_exception = e
+  end
+end
+
+Then /^pickled_aruba should fail with "([^"]*)"$/ do |error_message|
+  @aruba_exception.message.should =~ regexp(error_message)
+end
+
+Then /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
+  proc {steps multiline_step}.should raise_error(RSpec::Expectations::ExpectationNotMetError)
+end

data/features/support/env.rb

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

data/lib/pickled_aruba.rb

@@ -0,0 +1,2 @@
+require 'pickled_aruba/version'
+require 'pickled_aruba/cucumber'

data/lib/pickled_aruba/api.rb

@@ -0,0 +1,242 @@
+require 'tempfile'
+require 'rbconfig'
+require 'background_process'
+
+module PickledAruba
+  module Api
+    def in_current_dir(&block)
+      _mkdir(current_dir)
+      Dir.chdir(current_dir, &block)
+    end
+
+    def current_dir
+      File.join(*dirs)
+    end
+
+    def cd(dir)
+      dirs << dir
+      raise "#{current_dir} is not a directory." unless File.directory?(current_dir)
+    end
+
+    def dirs
+      @dirs ||= ['tmp/pickled_aruba']
+    end
+
+    def create_file(file_name, file_content, check_presence = false)
+      in_current_dir do
+        raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
+        _mkdir(File.dirname(file_name))
+        File.open(file_name, 'w') { |f| f << file_content }
+      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 create_dir(dir_name)
+      in_current_dir do
+        _mkdir(dir_name)
+      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 check_file_content(file, partial_content, expect_match)
+      regexp = regexp(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_exact_file_content(file, exact_content)
+      in_current_dir do
+        IO.read(file).should == exact_content
+      end
+    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 _mkdir(dir_name)
+      FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
+    end
+
+    def unescape(string)
+       eval(%{"#{string}"})
+    end
+
+    def regexp(string_or_regexp, case_insensitive = :case_sensitive)
+      Regexp === string_or_regexp ? string_or_regexp : Regexp.compile(Regexp.escape(string_or_regexp), (case_insensitive == :case_insensitive))
+    end
+
+    def combined_output
+      if @interactive
+        interactive_output
+      else
+        @last_stdout + @last_stderr
+      end
+    end
+
+    def assert_partial_output(partial_output, case_insensitive = :case_sensitive)
+      combined_output.should =~ regexp(partial_output, case_insensitive)
+    end
+
+    def assert_passing_with(partial_output, case_insensitive = :case_sensitive)
+      assert_exit_status_and_partial_output(true, partial_output, case_insensitive)
+    end
+
+    def assert_failing_with(partial_output, case_insensitive = :case_sensitive)
+      assert_exit_status_and_partial_output(false, partial_output, case_insensitive)
+    end
+
+    def assert_exit_status_and_partial_output(expect_to_pass, partial_output, case_insensitive = :case_sensitive)
+      assert_partial_output(partial_output, case_insensitive)
+      if expect_to_pass
+        @last_exit_status.should == 0
+      else
+        @last_exit_status.should_not == 0
+      end
+    end
+    
+    def install_gems(gemfile)
+      create_file("Gemfile", gemfile)
+      if ENV['GOTGEMS'].nil?
+        run("gem install bundler")
+        run("bundle --no-color install")
+      end
+    end
+
+    def run(cmd, fail_on_error=true)
+      cmd = detect_ruby(cmd)
+
+      in_current_dir do
+        announce_or_puts("$ cd #{Dir.pwd}") if @announce_dir
+        announce_or_puts("$ #{cmd}") if @announce_cmd
+        ps = BackgroundProcess.run(cmd)
+        @last_exit_status = ps.exitstatus # waits for the process to finish
+        @last_stdout = ps.stdout.read
+        announce_or_puts(@last_stdout) if @announce_stdout
+        @last_stderr = ps.stderr.read
+        announce_or_puts(@last_stderr) if @announce_stderr
+      end
+
+      if(@last_exit_status != 0 && fail_on_error)
+        fail("Exit status was #{@last_exit_status}. Output:\n#{combined_output}")
+      end
+
+      @last_stderr
+    end
+
+    def run_interactive(cmd)
+      cmd = detect_ruby(cmd)
+
+      in_current_dir do
+        @interactive = BackgroundProcess.run(cmd)
+      end
+    end
+
+    def interactive_output
+      if @interactive
+        @interactive.wait(1) || @interactive.kill('TERM')
+        @interactive.stdout.read
+      else
+        ""
+      end
+    end
+
+    def write_interactive(input)
+      @interactive.stdin.write(input)
+    end
+
+    def announce_or_puts(msg)
+      if(@puts)
+        puts(msg)
+      else
+        announce(msg)
+      end
+    end
+
+    def detect_ruby(cmd)
+      if cmd =~ /^ruby\s/
+        cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+      else
+        cmd
+      end
+    end
+
+    def current_ruby
+      File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    end
+
+    def use_clean_gemset(gemset)
+      run(%{rvm gemset create "#{gemset}"}, true)
+      if @last_stdout =~ /'#{gemset}' gemset created \((.*)\)\./
+        gem_home = $1
+        set_env('GEM_HOME', gem_home)
+        set_env('GEM_PATH', gem_home)
+        set_env('BUNDLE_PATH', gem_home)
+
+        paths = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+        paths.unshift(File.join(gem_home, 'bin'))
+        set_env('PATH', paths.uniq.join(File::PATH_SEPARATOR))
+
+        run("gem install bundler", true)
+      else
+        raise "I didn't understand rvm's output: #{@last_stdout}"
+      end
+    end
+
+    def unset_bundler_env_vars
+      %w[RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE].each do |key|
+        set_env(key, nil)
+      end
+    end
+
+    def set_env(key, value)
+      announce_or_puts(%{$ export #{key}="#{value}"}) if @announce_env
+      original_env[key] = ENV.delete(key)
+      ENV[key] = value
+    end
+
+    def restore_env
+      original_env.each do |key, value|
+        ENV[key] = value
+      end
+    end
+    
+    def original_env
+      @original_env ||= {}
+    end
+
+    def ensure_newline(str)
+      str.chomp << "\n"
+    end
+  end
+end

data/lib/pickled_aruba/cucumber.rb

@@ -0,0 +1,236 @@
+require 'pickled_aruba/api'
+
+World(PickledAruba::Api)
+
+Before('@disable-bundler') do
+  unset_bundler_env_vars
+end
+
+Before do
+  @__pickled_aruba_original_paths = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
+  ENV['PATH'] = ([File.expand_path('bin')] + @__pickled_aruba_original_paths).join(File::PATH_SEPARATOR)
+end
+
+After do
+  ENV['PATH'] = @__pickled_aruba_original_paths.join(File::PATH_SEPARATOR)
+end
+
+Before do
+  FileUtils.rm_rf(current_dir)
+end
+
+Before('@puts') do
+  @puts = true
+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-dir') do
+  @announce_dir = true
+end
+
+Before('@announce-env') do
+  @announce_env = true
+end
+
+Before('@announce') do
+  @announce_stdout = true
+  @announce_stderr = true
+  @announce_cmd = true
+  @announce_dir = true
+  @announce_env = true
+end
+
+After do
+  restore_env
+end
+
+Given /^I'm using a clean gemset "([^"]*)"$/ do |gemset|
+  use_clean_gemset(gemset)
+end
+
+Given /^a directory named "([^"]*)"$/ do |dir_name|
+  create_dir(dir_name)
+end
+
+Given /^a file named "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+Given /^an empty file named "([^"]*)"$/ do |file_name|
+  create_file(file_name, "")
+end
+
+When /^I write to "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content, false)
+end
+
+When /^I overwrite "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content, true)
+end
+
+When /^I append to "([^"]*)" with:$/ do |file_name, file_content|
+  append_to_file(file_name, file_content)
+end
+
+When /^I cd to "([^"]*)"$/ do |dir|
+  cd(dir)
+end
+
+When /^I run "(.*)"$/ do |cmd|
+  run(unescape(cmd), false)
+end
+
+When /^I successfully run "(.*)"$/ do |cmd|
+  run(unescape(cmd))
+end
+
+When /^I run "([^"]*)" interactively$/ do |cmd|
+  run_interactive(unescape(cmd))
+end
+
+When /^I type "([^"]*)"$/ do |input|
+  write_interactive(ensure_newline(input))
+end
+
+#(\w+ |\".*?\"|'.*?')
+#(\w+)|(?:')(.+)(?:')|(?: )(\w+)|(\w+)(?: )
+
+Then /^the output should(, regardless of case,|) contain "([^"]*)"( each of these|)$/ do |case_insensitive, partial_output, is_array|
+  (is_array == nil ? [partial_output] : partial_output.scan(/(\w+)|(?:')(.+)(?:')/).flatten.compact).each do |partial_output_each|
+    assert_partial_output(partial_output_each, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+  end
+end
+
+Then /^the output should not(, regardless of case,|) contain "([^"]*)"$/ do |case_insensitive, partial_output|
+  combined_output.should_not =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the output should(, regardless of case,|) contain:$/ do |case_insensitive, partial_output|
+  combined_output.should =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the output should not(, regardless of case,|) contain:$/ do |case_insensitive, partial_output|
+  combined_output.should_not =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the output should(, regardless of case,|) contain exactly "([^"]*)"$/ do |case_insensitive, exact_output|
+  combined_output.should == unescape(exact_output) if case_insensitive == ""
+  combined_output.downcase.should == unescape(exact_output).downcase if case_insensitive != nil
+end
+
+Then /^the output should(, regardless of case,|) contain exactly:$/ do |case_insensitive, exact_output|
+  combined_output.should == exact_output if case_insensitive == ""  
+  combined_output.downcase.should == exact_output.downcase if case_insensitive == ""  
+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
+Then /^the output should match \/([^\/]*)\/$/ do |partial_output|
+  combined_output.should =~ /#{partial_output}/
+end
+
+Then /^the output should match \/([^\/]*)\/i$/ do |partial_output|
+  combined_output.should =~ /#{partial_output}/i
+end
+
+Then /^the output should not match \/([^\/]*)\/$/ do |partial_output|
+  combined_output.should_not =~ /#{partial_output}/
+end
+
+Then /^the output should not match \/([^\/]*)\/i$/ do |partial_output|
+  combined_output.should_not =~ /#{partial_output}/i
+end
+
+Then /^the output should(, regardless of case,|) match:$/ do |case_insensitive, partial_output|
+ combined_output.should =~ (case_insensitive == "" ? /#{partial_output}/m : /#{partial_output}/mi)
+end
+
+Then /^the output should not(, regardless of case,|) match:$/ do |case_insensitive, partial_output|
+ combined_output.should_not =~ (case_insensitive == "" ? /#{partial_output}/m : /#{partial_output}/mi)
+end
+
+Then /^the exit status should be (\d+)$/ do |exit_status|
+  @last_exit_status.should == exit_status.to_i
+end
+
+Then /^the exit status should not be (\d+)$/ do |exit_status|
+  @last_exit_status.should_not == exit_status.to_i
+end
+
+Then /^it should(, regardless of case,|) (pass|fail) with:$/ do |case_insensitive, pass_fail, partial_output|
+  self.__send__("assert_#{pass_fail}ing_with", partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^it should(, regardless of case,|) (pass|fail) with regexp?:$/ do |case_insensitive, pass_fail, partial_output|
+  Then "the output should#{case_insensitive} match:", partial_output
+  if pass_fail == 'pass'
+    @last_exit_status.should == 0
+  else
+    @last_exit_status.should_not == 0
+  end
+end
+
+Then /^the stderr should(, regardless of case,|) contain "([^"]*)"$/ do |case_insensitive, partial_output|
+  @last_stderr.should =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the stdout should(, regardless of case,|) contain "([^"]*)"$/ do |case_insensitive, partial_output|
+  @last_stdout.should =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the stderr should not(, regardless of case,|) contain "([^"]*)"$/ do |case_insensitive, partial_output|
+  @last_stderr.should_not =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the stdout should not(, regardless of case,|) contain "([^"]*)"$/ do |case_insensitive, partial_output|
+  @last_stdout.should_not =~ regexp(partial_output, (case_insensitive == "" ? :case_sensitive : :case_insensitive))
+end
+
+Then /^the following files should exist:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, true)
+end
+
+Then /^the following files should not exist:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
+end
+
+Then /^the following directories should exist:$/ do |directories|
+  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, true)
+end
+
+Then /^the following directories should not exist:$/ do |directories|
+  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, false)
+end
+
+Then /^the file "([^"]*)" should contain "([^"]*)"$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end
+
+Then /^the file "([^"]*)" should not contain "([^"]*)"$/ do |file, partial_content|
+  check_file_content(file, partial_content, false)
+end
+
+Then /^the file "([^"]*)" should contain exactly:$/ do |file, exact_content|
+  check_exact_file_content(file, exact_content)
+end
+
+Then /^the file "([^"]*)" should match \/([^\/]*)\/$/ do |file, partial_content|
+  check_file_content(file, /#{partial_content}/, true)
+end
+
+Then /^the file "([^"]*)" should not match \/([^\/]*)\/$/ do |file, partial_content|
+  check_file_content(file, /#{partial_content}/, false)
+end