aruba 0.2.4 → 0.2.5

data/History.txt

@@ -1,3 +1,18 @@
+== 0.2.5
+
+=== New Features
+* Added 'a file named "whatever" should (not) exist' (Robert Speicher)
+* Added 'a directory named "whatever" should (not) exist' (Robert Speicher)
+* Added /^the stderr should contain exactly:"$/ (Aslak Hellesøy)
+* Added /^the stdout should contain exactly:"$/ (Aslak Hellesøy)
+* Added /it should pass with exactly:/ (Aslak Hellesøy)
+* @announce, @announce-dir and @announce-cmd for interactive processes (Mike Sassak)
+* Add step defs for detecting output, stdout and stderr by process name (Mike Sassak)
+
+=== Bug fixes
+* Stop all processes before verifying filesystem changes to ensure async operations are complete (#17 Mike Sassak)
+* Outputting large amounts of data causes run steps to hang (#18 Mike Sassak)
+
 == 0.2.4
 
 === New Features
@@ -97,4 +112,4 @@
 * Better Regexp escaping (David Chelimsky)
 
 == 0.1.0
-* First release (David Chelimsky and Aslak Hellesøy)
+* First release (David Chelimsky and Aslak Hellesøy)

data/aruba.gemspec

@@ -2,14 +2,14 @@
 
 Gem::Specification.new do |s|
   s.name        = 'aruba'
-  s.version     = "0.2.4"
+  s.version     = "0.2.5"
   s.authors     = ["Aslak Hellesøy", "David Chelimsky"]
   s.description = 'CLI Steps for Cucumber, hand-crafted for you in Aruba'
   s.summary     = "aruba-#{s.version}"
   s.email       = 'cukes@googlegroups.com'
   s.homepage    = 'http://github.com/aslakhellesoy/aruba'
 
-  s.add_dependency 'cucumber', '~> 0.9.3'
+  s.add_dependency 'cucumber', '~> 0.9.4'
   s.add_dependency 'background_process' # Can't specify a version - bundler/rubygems chokes on '2.1'
   s.add_development_dependency 'rspec', '~> 2.0.1'
 

data/cucumber.yml

@@ -0,0 +1,2 @@
+default: --tags ~@wip
+wip: --wip --tags @wip

data/features/exit_statuses.feature

@@ -19,3 +19,7 @@ Feature: exit statuses
   Scenario: Unsuccessfully run something
     When I do aruba I successfully run "ruby -e 'exit 10'"
     Then aruba should fail with "Exit status was 10"
+
+  Scenario: Try to run something that doesn't exist
+    When I run "does_not_exist"
+    Then the exit status should be 1

data/features/file_system_commands.feature

@@ -67,14 +67,21 @@ Feature: file system commands
   Scenario: Check for absence of files
     Then the following files should not exist:
       | lorem/ipsum/dolor |
-      
+
+  Scenario: Check for presence of a single file
+    Given an empty file named "lorem/ipsum/dolor"
+    Then a file named "lorem/ipsum/dolor" should exist
+
+  Scenario: Check for absence of a single file
+    Then a file named "lorem/ipsum/dolor" should not exist
+
   Scenario: Check for presence of a subset of directories
     Given a directory named "foo/bar"
     Given a directory named "foo/bla"
     Then the following directories should exist:
       | foo/bar |
       | foo/bla |
-  
+
   Scenario: check for absence of directories
     Given a directory named "foo/bar"
     Given a directory named "foo/bla"
@@ -84,7 +91,18 @@ Feature: file system commands
       | foo/bar/ |
       | foo/bla/ |
     """
-  
+
+  Scenario: Check for presence of a single directory
+    Given a directory named "foo/bar"
+    Then a directory named "foo/bar" should exist
+
+  Scenario: Check for absence of a single directory
+    Given a directory named "foo/bar"
+    Then the following step should fail with Spec::Expectations::ExpectationNotMetError:
+      """
+      Then a directory named "foo/bar" should not exist
+      """
+
   Scenario: Check file contents
     Given a file named "foo" with:
       """

data/features/flushing.feature

@@ -0,0 +1,16 @@
+Feature: Flushing output
+
+  In order to test processes that output a lot of data
+  As a developer using Aruba
+  I want to make sure that large amounts of output aren't buffered
+
+  Scenario: Tons of output
+    When I run "ruby -e 'puts :a.to_s * 65536'"
+    Then the output should contain "a"
+    And the output should be 65536 bytes long
+
+  Scenario: Tons of interactive output
+    When I run "ruby -e 'len = gets.chomp; puts :a.to_s * len.to_i'" interactively
+    And I type "65536"
+    Then the output should contain "a"
+    And the output should be 65536 bytes long

data/features/interactive.feature

@@ -28,3 +28,11 @@ Feature: Interactive process control
       """
       7
       """
+
+  Scenario: Stop processes before checking for filesystem changes 
+    See: http://github.com/aslakhellesoy/aruba/issues#issue/17 for context
+
+    Given a directory named "rename_me"
+    When I run "mv rename_me renamed" interactively
+    Then a directory named "renamed" should exist
+    And a directory named "rename_me" should not exist

data/features/output.feature

@@ -75,6 +75,15 @@ Feature: Output
       hello
       """
 
+  Scenario: Match passing exit status and exact output
+    When I run "ruby -e 'puts \"hello\\nworld\"'"
+    Then it should pass with exactly:
+      """
+      hello
+      world
+
+      """
+
   @announce-stdout
   Scenario: Match failing exit status and partial output
     When I run "ruby -e 'puts \"hello\\nworld\";exit 99'"
@@ -83,6 +92,15 @@ Feature: Output
       hello
       """
 
+  Scenario: Match failing exit status and exact output
+    When I run "ruby -e 'puts \"hello\\nworld\";exit 99'"
+    Then it should fail with exactly:
+      """
+      hello
+      world
+
+      """
+
   @announce-stdout
   Scenario: Match failing exit status and output with regex
     When I run "ruby -e 'puts \"hello\\nworld\";exit 99'"
@@ -102,3 +120,52 @@ Feature: Output
     When I run "ruby -e 'STDERR.puts \"hello\\nworld\";exit 99'"
     Then the stderr should contain "hello"
     Then the stdout should not contain "hello"
+
+  Scenario: Detect output from all processes
+    When I run "ruby -e 'puts \"hello world!\"'"
+    And I run "ruby -e 'puts gets.chomp.reverse'" interactively
+    And I type "hello"
+    Then the output should contain exactly:
+      """
+      hello world!
+      olleh
+
+      """
+
+  Scenario: Detect stdout from all processes
+    When I run "ruby -e 'puts \"hello world!\"'"
+    And I run "ruby -e 'puts gets.chomp.reverse'" interactively
+    And I type "hello"
+    Then the stdout should contain "hello world!\nolleh"
+    And the stderr should not contain "hello world!\nolleh"
+
+  Scenario: Detect stderr from all processes
+    When I run "ruby -e 'STDERR.puts \"hello world!\"'"
+    And I run "ruby -e 'STDERR.puts gets.chomp.reverse'" interactively
+    And I type "hello"
+    Then the stderr should contain "hello world!\nolleh"
+    And the stdout should not contain "hello world!\nolleh"
+
+  Scenario: Detect output from named source
+    When I run "ruby -e 'puts :simple'"
+    And I run "ruby -e 'puts gets.chomp'" interactively
+    And I type "interactive"
+    Then the output from "ruby -e 'puts :simple'" should contain "simple"
+    And the output from "ruby -e 'puts gets.chomp'" should not contain "simple"
+
+  Scenario: Detect stdout from named source
+    When I run "ruby -e 'puts :hello'"
+    And I run "ruby -e 'puts :goodbye'"
+    Then the stdout from "ruby -e 'puts :hello'" should contain "hello"
+    And the stderr from "ruby -e 'puts :hello'" should not contain "hello"
+    And the stdout from "ruby -e 'puts :goodbye'" should not contain "hello"
+
+  Scenario: Detect stderr from named source
+    When I run "ruby -e 'STDERR.puts :hello'"
+    And I run "ruby -e 'puts :goodbye'"
+    Then the stderr from "ruby -e 'STDERR.puts :hello'" should contain "hello"
+    And the stdout from "ruby -e 'STDERR.puts :hello'" should not contain "hello"
+    And the stderr from "ruby -e 'puts :goodbye'" should not contain "hello"
+
+  @wip
+  Scenario: Detect output from named source with custom name

data/features/step_definitions/aruba_dev_steps.rb

@@ -6,10 +6,19 @@ When /^I do aruba (.*)$/ do |aruba_step|
   end
 end
 
+# Useful for debugging timing problems
+When /^sleep (\d+)$/ do |time|
+  sleep time.to_i
+end
+
 Then /^aruba should fail with "([^"]*)"$/ do |error_message|
-  @aruba_exception.message.should =~ regexp(error_message)
+  @aruba_exception.message.should include(unescape(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
+
+Then /^the output should be (\d+) bytes long$/ do |length|
+  all_output.chomp.length.should == length.to_i
+end

data/lib/aruba/api.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'rbconfig'
-require 'background_process'
+
+require 'aruba/process'
 
 module Aruba
   module Api
@@ -49,7 +50,7 @@ module Aruba
     end
 
     def check_file_presence(paths, expect_presence)
-      in_current_dir do
+      prep_for_fs_check do
         paths.each do |path|
           if expect_presence
             File.should be_file(path)
@@ -62,7 +63,7 @@ module Aruba
 
     def check_file_content(file, partial_content, expect_match)
       regexp = regexp(partial_content)
-      in_current_dir do
+      prep_for_fs_check do 
         content = IO.read(file)
         if expect_match
           content.should =~ regexp
@@ -73,13 +74,11 @@ module Aruba
     end
   
     def check_exact_file_content(file, exact_content)
-      in_current_dir do
-        IO.read(file).should == exact_content
-      end
+      prep_for_fs_check { IO.read(file).should == exact_content }
     end
   
     def check_directory_presence(paths, expect_presence)
-      in_current_dir do
+      prep_for_fs_check do
         paths.each do |path|
           if expect_presence
             File.should be_directory(path)
@@ -90,6 +89,11 @@ module Aruba
       end
     end
 
+    def prep_for_fs_check(&block)
+      stop_processes!
+      in_current_dir{ block.call }
+    end
+
     def _mkdir(dir_name)
       FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
     end
@@ -102,16 +106,39 @@ module Aruba
       Regexp === string_or_regexp ? string_or_regexp : Regexp.compile(Regexp.escape(string_or_regexp))
     end
 
-    def combined_output
-      if @interactive
-        interactive_output
-      else
-        @last_stdout + @last_stderr
-      end
+    def output_from(cmd)
+      cmd = detect_ruby(cmd)
+      processes[cmd].output
+    end
+
+    def stdout_from(cmd)
+      cmd = detect_ruby(cmd)
+      processes[cmd].stdout
+    end
+
+    def stderr_from(cmd)
+      cmd = detect_ruby(cmd)
+      processes[cmd].stderr
+    end
+
+    def all_stdout
+      processes.values.inject("") { |out, ps| out << ps.stdout }
+    end
+
+    def all_stderr
+      processes.values.inject("") { |out, ps| out << ps.stderr }
+    end
+
+    def all_output
+      all_stdout << all_stderr
+    end
+
+    def assert_exact_output(exact_output)
+      all_output.should == exact_output
     end
 
     def assert_partial_output(partial_output)
-      combined_output.should =~ regexp(partial_output)
+      all_output.should include(unescape(partial_output))
     end
 
     def assert_passing_with(partial_output)
@@ -124,6 +151,19 @@ module Aruba
 
     def assert_exit_status_and_partial_output(expect_to_pass, partial_output)
       assert_partial_output(partial_output)
+      assert_exiting_with(expect_to_pass)
+    end
+
+    def assert_exit_status_and_output(expect_to_pass, output, expect_exact_output)
+      if expect_exact_output
+        assert_exact_output(output)
+      else
+        assert_partial_output(output)
+      end
+      assert_exiting_with(expect_to_pass)
+    end
+
+    def assert_exiting_with(expect_to_pass)
       if expect_to_pass
         @last_exit_status.should == 0
       else
@@ -139,42 +179,44 @@ module Aruba
       end
     end
 
-    def run(cmd, fail_on_error=true)
+    def processes
+      @processes ||= {}
+    end
+
+    def stop_processes!
+      processes.each do |_, process|
+        process.stop
+      end
+    end
+
+    def run(cmd)
       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
+        
+        process = processes[cmd] = Process.new(cmd)
+        process.run!
 
-      if(@last_exit_status != 0 && fail_on_error)
-        fail("Exit status was #{@last_exit_status}. Output:\n#{combined_output}")
+        block_given? ? yield(process) : process
       end
-
-      @last_stderr
     end
 
-    def run_interactive(cmd)
-      cmd = detect_ruby(cmd)
+    def run_simple(cmd, fail_on_error=true)
+      @last_exit_status = run(cmd) do |process|
+        announce_or_puts(process.stdout) if @announce_stdout
+        announce_or_puts(process.stderr) if @announce_stderr
+        process.stop
+      end
 
-      in_current_dir do
-        @interactive = BackgroundProcess.run(cmd)
+      if(@last_exit_status != 0 && fail_on_error)
+        fail("Exit status was #{@last_exit_status}. Output:\n#{all_output}")
       end
     end
 
-    def interactive_output
-      if @interactive
-        @interactive.wait(1) || @interactive.kill('TERM')
-        @interactive.stdout.read
-      else
-        ""
-      end
+    def run_interactive(cmd)
+      @interactive = run(cmd)
     end
 
     def write_interactive(input)

data/lib/aruba/cucumber.rb

@@ -92,11 +92,11 @@ When /^I cd to "([^"]*)"$/ do |dir|
 end
 
 When /^I run "(.*)"$/ do |cmd|
-  run(unescape(cmd), false)
+  run_simple(unescape(cmd), false)
 end
 
 When /^I successfully run "(.*)"$/ do |cmd|
-  run(unescape(cmd))
+  run_simple(unescape(cmd))
 end
 
 When /^I run "([^"]*)" interactively$/ do |cmd|
@@ -108,27 +108,35 @@ When /^I type "([^"]*)"$/ do |input|
 end
 
 Then /^the output should contain "([^"]*)"$/ do |partial_output|
-  assert_partial_output(partial_output)
+  assert_partial_output(unescape(partial_output))
+end
+
+Then /^the output from "([^"]*)" should contain "([^"]*)"$/ do |cmd, partial_output|
+  output_from(cmd).should include(unescape(partial_output))
+end
+
+Then /^the output from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, partial_output|
+  output_from(cmd).should_not include(unescape(partial_output))
 end
 
 Then /^the output should not contain "([^"]*)"$/ do |partial_output|
-  combined_output.should_not =~ regexp(partial_output)
+  all_output.should_not include(unescape(partial_output))
 end
 
 Then /^the output should contain:$/ do |partial_output|
-  combined_output.should =~ regexp(partial_output)
+  all_output.should include(unescape(partial_output))
 end
 
 Then /^the output should not contain:$/ do |partial_output|
-  combined_output.should_not =~ regexp(partial_output)
+  all_output.should_not include(unescape(partial_output))
 end
 
 Then /^the output should contain exactly "([^"]*)"$/ do |exact_output|
-  combined_output.should == unescape(exact_output)
+  all_output.should == unescape(exact_output)
 end
 
 Then /^the output should contain exactly:$/ do |exact_output|
-  combined_output.should == exact_output
+  all_output.should == unescape(exact_output)
 end
 
 # "the output should match" allows regex in the partial_output, if
@@ -136,11 +144,11 @@ end
 # 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}/
+  all_output.should =~ /#{partial_output}/
 end
  
 Then /^the output should match:$/ do |partial_output|
-  combined_output.should =~ /#{partial_output}/m
+  all_output.should =~ /#{partial_output}/m
 end
 
 Then /^the exit status should be (\d+)$/ do |exit_status|
@@ -155,6 +163,10 @@ Then /^it should (pass|fail) with:$/ do |pass_fail, partial_output|
   self.__send__("assert_#{pass_fail}ing_with", partial_output)
 end
 
+Then /^it should (pass|fail) with exactly:$/ do |pass_fail, exact_output|
+  assert_exit_status_and_output(pass_fail == "pass", exact_output, true)
+end
+
 Then /^it should (pass|fail) with regexp?:$/ do |pass_fail, partial_output|
   Then "the output should match:", partial_output
   if pass_fail == 'pass'
@@ -165,19 +177,43 @@ Then /^it should (pass|fail) with regexp?:$/ do |pass_fail, partial_output|
 end
 
 Then /^the stderr should contain "([^"]*)"$/ do |partial_output|
-  @last_stderr.should =~ regexp(partial_output)
+  all_stderr.should include(unescape(partial_output))
+end
+
+Then /^the stderr should contain exactly:$/ do |exact_output|
+  @last_stderr.should == exact_output
 end
 
 Then /^the stdout should contain "([^"]*)"$/ do |partial_output|
-  @last_stdout.should =~ regexp(partial_output)
+  all_stdout.should include(unescape(partial_output))
+end
+
+Then /^the stdout should contain exactly:$/ do |exact_output|
+  @stdout.should == exact_output
 end
 
 Then /^the stderr should not contain "([^"]*)"$/ do |partial_output|
-  @last_stderr.should_not =~ regexp(partial_output)
+  all_stderr.should_not include(unescape(partial_output))
 end
 
 Then /^the stdout should not contain "([^"]*)"$/ do |partial_output|
-  @last_stdout.should_not =~ regexp(partial_output)
+  all_stdout.should_not include(unescape(partial_output))
+end
+
+Then /^the stdout from "([^"]*)" should contain "([^"]*)"$/ do |cmd, partial_output|
+  stdout_from(cmd).should include(unescape(partial_output))
+end
+
+Then /^the stdout from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, partial_output|
+  stdout_from(cmd).should_not include(unescape(partial_output))
+end
+
+Then /^the stderr from "([^"]*)" should contain "([^"]*)"$/ do |cmd, partial_output|
+  stderr_from(cmd).should include(unescape(partial_output))
+end
+
+Then /^the stderr from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, partial_output|
+  stderr_from(cmd).should_not include(unescape(partial_output))
 end
 
 Then /^the file "([^"]*)" should not exist$/ do |file_name|
@@ -192,6 +228,14 @@ Then /^the following files should not exist:$/ do |files|
   check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
 end
 
+Then /^a file named "([^"]*)" should exist$/ do |file|
+  check_file_presence([file], true)
+end
+
+Then /^a file named "([^"]*)" should not exist$/ do |file|
+  check_file_presence([file], false)
+end
+
 Then /^the following directories should exist:$/ do |directories|
   check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, true)
 end
@@ -200,6 +244,14 @@ Then /^the following directories should not exist:$/ do |directories|
   check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, false)
 end
 
+Then /^a directory named "([^"]*)" should exist$/ do |directory|
+  check_directory_presence([directory], true)
+end
+
+Then /^a directory named "([^"]*)" should not exist$/ do |directory|
+  check_directory_presence([directory], false)
+end
+
 Then /^the file "([^"]*)" should contain "([^"]*)"$/ do |file, partial_content|
   check_file_content(file, partial_content, true)
 end

data/lib/aruba/process.rb

@@ -0,0 +1,45 @@
+require 'background_process'
+
+module Aruba
+  class Process
+    def initialize(cmd)
+      @cmd = cmd
+    end
+
+    def run!(&block)
+      @process = BackgroundProcess.run(@cmd)
+      yield self if block_given?
+    end
+
+    def stdin
+      @process.stdin
+    end
+
+    def output
+      stdout + stderr
+    end
+
+    def stdout
+      if @process
+        @stdout ||= @process.stdout.read
+      else
+        ''
+      end
+    end
+
+    def stderr
+      if @process
+        @stderr ||= @process.stderr.read
+      else
+        ''
+      end
+    end
+
+    def stop
+      if @process
+        status = @process.wait(1)
+        status && status.exitstatus
+      end
+    end
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 4
-  version: 0.2.4
+  - 5
+  version: 0.2.5
 platform: ruby
 authors: 
 - "Aslak Helles\xC3\xB8y"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-02 00:00:00 +00:00
+date: 2010-11-13 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,8 +28,8 @@ dependencies:
         segments: 
         - 0
         - 9
-        - 3
-        version: 0.9.3
+        - 4
+        version: 0.9.4
   type: :runtime
   prerelease: false
   version_requirements: *id001
@@ -83,8 +83,10 @@ files:
 - Rakefile
 - aruba.gemspec
 - config/.gitignore
+- cucumber.yml
 - features/exit_statuses.feature
 - features/file_system_commands.feature
+- features/flushing.feature
 - features/interactive.feature
 - features/output.feature
 - features/step_definitions/aruba_dev_steps.rb
@@ -92,6 +94,7 @@ files:
 - lib/aruba.rb
 - lib/aruba/api.rb
 - lib/aruba/cucumber.rb
+- lib/aruba/process.rb
 has_rdoc: true
 homepage: http://github.com/aslakhellesoy/aruba
 licenses: []
@@ -106,7 +109,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3353510939538542612
+      hash: 1671730072629991587
       segments: 
       - 0
       version: "0"
@@ -115,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3353510939538542612
+      hash: 1671730072629991587
       segments: 
       - 0
       version: "0"
@@ -125,10 +128,11 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: aruba-0.2.4
+summary: aruba-0.2.5
 test_files: 
 - features/exit_statuses.feature
 - features/file_system_commands.feature
+- features/flushing.feature
 - features/interactive.feature
 - features/output.feature
 - features/step_definitions/aruba_dev_steps.rb