aruba-doubles 0.1.1 → 0.2.0

data/Guardfile

@@ -0,0 +1,15 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2, :cli => '--color' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})           { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')        { "spec" }
+end
+
+guard 'cucumber' do
+  watch(%r{^lib/.+$})                 { 'features' }
+  watch(%r{^features/.+\.feature$})
+  watch(%r{^features/support/.+$})    { 'features' }
+  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+end

data/README.md

@@ -4,11 +4,11 @@ Stub and mock command line applications with Cucumber
 
 ## Introduction
 
-Let's say you develop a command line application ([BDD](http://en.wikipedia.org/wiki/Behavior_Driven_Development)-style with [Cucumber](http://cukes.info/) and [Aruba](https://github.com/cucumber/aruba)) which itself relys on other CLI stuff that makes testing harder (i.e. it calls under certain conditions `kill_the_cat`... Don't do that in your tests!).
-Mocking and stubbing with Cucumber is usually [not recommended](https://github.com/cucumber/cucumber/wiki/Mocking-and-Stubbing-with-Cucumber) and tricky because we have do do it across processes but in some cases it could make your life easier (Your cat will thank you later.)
-Aruba-Double lets you fake those evil CLI applications by injecting temporary doubles in your system PATH during tests.
+Developing a command line application in proper [BDD](http://en.wikipedia.org/wiki/Behavior_Driven_Development)-style with [Cucumber](http://cukes.info/) and [Aruba](https://github.com/cucumber/aruba) can be cumbersome, when your application depends on other CLI stuff (i.e. calling under certain conditions `kill_the_cat`).
+Mocking and stubbing with Cucumber is usually [not recommended](https://github.com/cucumber/cucumber/wiki/Mocking-and-Stubbing-with-Cucumber) and tricky because we have do do it across processes but, in some cases it could make your life easier (Your cat will thank you later!)
+Aruba-Doubles are some convenient Cucumber steps to fake CLI applications during your tests (by injecting temporary doubles in front of your PATH).
 
-(Note: This little Gem isn't an official part of Aruba but it works as a complement, so they'll play nice together.)
+(Note: Aruba-Doubles is not an official part of Aruba but a good companion in the same domain, hence the name.)
 
 ## Usage
 
@@ -20,33 +20,46 @@ Then, `require` the library in one of your ruby files under `features/support` (
 
     require 'aruba-doubles/cucumber'
 
-Here are some examples:
-
-		Scenario: Stubbing with exit code and stderr
-			Given a double of "kill_the_cat" with exit status 255 and stderr:
-				"""
-				ERROR: You don't even have a cat!
-				"""
-			When I run `my_fancy_new_script`
-			Then ...
-			
-		Scenario: Mocking
-			Given a double of "kill_the_cat --gently" with stdout:
-				"""
-				R.I.P.
-				"""
-			When I run `kill_the_cat`
-			Then the stdout should contain exactly:
-				"""
-				"""
-			And the stderr should contain exactly:
-				"""
-				expected: kill_the_cat --gently
-				     got: kill_the_cat 
-				"""
+### Stubbing
+
+You can stub commands by using the `I could run` steps:
+
+	Background:
+		Given I could run `kill_the_cat` with stdout:
+			"""
+			R.I.P.
+			"""
+
+	Scenario: Call stubbed command
+		When I run `kill_the_cat`
+		Then the exit status should be 0
+		And the stdout should contain "R.I.P."
+		And the stderr should be empty
+
+	Scenario: Call stubbed command with unexpected argument
+		When I run `kill_the_cat --force`
+		Then the exit status should not be 0
+		And the stdout should be empty
+		And the stderr should contain "--force"
+
+	Scenario: Add expected arguments to stub
+		And I could run `kill_the_cat --gently` with exit status 255 and stderr:
+			"""
+			ERROR: Unable to kill gently... with a chainsaw!
+			"""
+		When I run `kill_the_cat`
+		Then the stdout should contain "R.I.P."
+		And the stderr should be empty
+		When I run `kill_the_cat --gently`
+		Then the stdout should be empty
+		And the stderr should contain "ERROR: Unable to kill gently..."
 
 Take a peek at `features/*.feature` for further examples and at `lib/aruba-doubles/cucumber.rb` for all step definitions.
 
+### Mocking
+
+Currently you can't check if a double was called at all, but hopefully this will be a feature in the future (patches are welcome!).
+
 ## Caveats
 
 Aruba-Double won't work, if your command...
@@ -55,6 +68,9 @@ Aruba-Double won't work, if your command...
 * defines its own PATH
 * calls build-in commands from your shell like `echo` (but who want to stub that)
 
+Of course you'll only see stdout and sterr from doubles if these aren't silenced by the calling command (like redirecting to /dev/null.)
+Keep that in mind when you want to compare expected and acutal arguments.
+
 Also note that doubles will be created as scripts in temporary directories on your filesystem, which might slow down your tests.
 
 ## Note on Patches/Pull Requests

data/Rakefile

@@ -1,8 +1,14 @@
 require 'bundler/gem_tasks'
 require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
 
 Cucumber::Rake::Task.new(:features) do |t|
   t.cucumber_opts = "--format pretty"
 end
 
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = "./spec/**/*_spec.rb"
+end
+
 task :default => :features

data/aruba-doubles.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'aruba-doubles'
-  s.version     = '0.1.1'
+  s.version     = '0.2.0'
   s.authors     = ["Björn Albers"]
   s.email       = ["bjoernalbers@googlemail.com"]
   s.description = 'Stub command line applications with Cucumber'
@@ -12,6 +12,8 @@ Gem::Specification.new do |s|
   s.add_dependency 'cucumber', '>= 1.0.2'
   
   s.add_development_dependency 'aruba', '>= 0.4.6'
+  s.add_development_dependency 'guard-cucumber', '>= 0.7.3'
+  s.add_development_dependency 'guard-rspec', '>= 0.5.1'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/features/double.feature

@@ -0,0 +1,85 @@
+Feature: Double command line applications
+
+	In order to double command line applications
+	As a developer using Cucumber
+	I want to use the "I could run" steps
+
+	Scenario: Stub with default stdout, stderr and exit status
+		Given I could run `foo`
+		When I successfully run `foo`
+		Then the stdout should be empty
+		And the stderr should be empty
+
+	Scenario: Stub stdout
+		Given I could run `foo` with stdout:
+			"""
+			hello, world.
+			"""
+		When I successfully run `foo`
+		Then the stdout should contain exactly:
+			"""
+			hello, world.
+			
+			"""
+		And the stderr should be empty
+
+	 Scenario: Stub stderr
+		Given I could run `foo` with stderr:
+	 		"""
+	 		error: something crashed!
+	 		"""
+	 	When I successfully run `foo`
+	 	And the stdout should be empty
+	 	Then the stderr should contain exactly:
+	 		"""
+	 		error: something crashed!
+   
+	 		"""
+
+	Scenario: Stub exit status
+		Given I could run `foo` with exit status 255
+		When I run `foo`
+		Then the exit status should be 255
+		And the stdout should be empty
+		And the stderr should be empty
+
+	Scenario: Stub exit status and stdout
+		Given I could run `foo` with exit status 255 and stdout:
+			"""
+			hello, world.
+			"""
+		When I run `foo`
+		Then the exit status should be 255
+		And the stdout should contain exactly:
+			"""
+			hello, world.
+			
+			"""			
+		And the stderr should be empty
+
+	Scenario: Run with unexpected arguments
+		Given I could run `foo --bar` with stdout:
+			"""
+			hello, world.
+			"""
+		When I run `foo --baz`
+		Then the exit status should not be 0
+		And the stdout should be empty
+		And the stderr should contain "Unexpected arguments"
+
+	Scenario: Stub multiple calls
+		Given I could run `foo --bar` with stdout:
+			"""
+			hello, bar.
+			"""
+		And I could run `foo --baz` with stdout:
+			"""
+			hello, baz.
+			"""
+		When I successfully run `foo --bar`
+		And the stdout should contain "hello, bar."
+		And the stdout should not contain "hello, baz."
+		And the stderr should be empty
+		When I successfully run `foo --baz`
+		And the stdout should contain "hello, baz."
+		And the stderr should be empty

data/features/environment-friendly.feature

@@ -9,12 +9,12 @@ Feature: Environment-friendly
 		Then the doubles directory should not exist
 
 	Scenario: Patch the original path only once
-		Given a double of "ls"
-		And a double of "ls"
+		Given I could run `ls`
+		And I could run `ls`
 		Then the path should include 1 doubles directory
 
 	Scenario: Create doubles directory...
-		Given a double of "ls"
+		Given I could run `ls`
 		When I keep the doubles directory in mind
 	
 	Scenario: ...and check that it was deleted

data/features/step_definitions/dev_steps.rb

@@ -14,4 +14,12 @@ Then /^the previous doubles directory should not exist$/ do
   File.should_not be_exist(@@previous_doubles_dir)
 end
 
+Then /^the (stdout|stderr) should be empty$/ do |stdout_stderr|
+  steps %Q{
+    Then the #{stdout_stderr} should contain exactly:
+			"""
+			"""
+  }
+end
+
 

data/lib/aruba-doubles/api.rb

@@ -1,17 +1,40 @@
+require 'aruba-doubles/double'
+
 module ArubaDoubles
   module Api
     def doubled?
       !@doubles_dir.nil?
     end
     
-    def create_double(file, options = {})
+    def create_double_by_cmd(cmd, options = {})
+      filename = cmd.split.first
+      arguments = cmd.split[1..-1]
+      create_double(filename, arguments, options)
+    end
+    
+    def create_double(filename, arguments, options = {})
       unless doubled?
         create_doubles_dir
         patch_original_path
-      end
-      write_double(file, options)
+      end   
+      write_double(filename, get_double(filename, arguments, options))
     end
     
+    def write_double(filename, double)
+      fullpath = File.expand_path(filename, @doubles_dir)
+      File.open(fullpath, 'w') do |f|
+        f.puts "#!/usr/bin/env ruby"
+        f.puts "# Doubled command line application by aruba-doubles\n"
+        f.puts "require 'aruba-doubles/double'"
+        f.puts "double = ArubaDoubles::Double.new(#{double.expectations.inspect})"
+        f.puts "double.run"
+        f.puts "puts double.stdout if double.stdout"
+        f.puts "warn double.stderr if double.stderr"
+        f.puts "exit(double.exit_status) if double.exit_status"
+      end
+      FileUtils.chmod(0755, fullpath)
+    end
+
     def remove_doubles
       restore_original_path
       remove_doubles_dir
@@ -22,32 +45,21 @@ module ArubaDoubles
     def create_doubles_dir
       @doubles_dir = Dir.mktmpdir
     end
+    
+    def doubles
+      @doubles ||= {}
+    end
+
+    def get_double(filename, arguments, options)
+      doubles[filename] ||= ArubaDoubles::Double.new
+      doubles[filename].could_receive(arguments, options)
+    end
 
     def patch_original_path
       @__aruba_doubles_original_path = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
       ENV['PATH'] = ([@doubles_dir] + @__aruba_doubles_original_path).join(File::PATH_SEPARATOR)
     end
 
-    def write_double(command_line, options = {})
-      args = command_line.split
-      filename = args.shift
-      double = File.expand_path(filename, @doubles_dir)
-      File.open(double, 'w') do |f|
-        f.puts "#!/usr/bin/env ruby"
-        f.puts "# Doubled command line application by aruba-doubles\n"
-        f.puts "unless ARGV.to_s == \"#{args}\""
-        f.puts "  warn \"expected: #{filename} #{args.join(' ')}\""
-        f.puts "  warn \"     got: #{filename} \#{ARGV.join(' ')}\""
-        f.puts "  exit(1)"
-        f.puts "end"
-        f.puts "puts ([File.basename(__FILE__)] + ARGV).join(' ')" if @repeat_arguments
-        f.puts "puts \"#{options[:stdout]}\"" if options[:stdout]
-        f.puts "warn \"#{options[:stderr]}\"" if options[:stderr]
-        f.puts "exit(#{options[:exit_status]})" if options[:exit_status]
-      end
-      FileUtils.chmod(0755, double)
-    end
-
     def restore_original_path
       ENV['PATH'] = @__aruba_doubles_original_path.join(File::PATH_SEPARATOR) unless doubled?
     end

data/lib/aruba-doubles/cucumber.rb

@@ -3,18 +3,18 @@ require 'aruba-doubles/api'
 
 World(ArubaDoubles::Api)
 
-Given /^a double of "([^"]*)"$/ do |file|
-  create_double(file)
+Given /^I could run `([^`]*)`$/ do |cmd|
+  create_double_by_cmd(cmd)
 end
 
-Given /^a double of "([^"]*)" with (stdout|stderr):$/ do |file, stdout_stderr, output|
-  create_double(file, stdout_stderr.to_sym => output)
+Given /^I could run `([^`]*)` with (stdout|stderr):$/ do |cmd, type, output|
+  create_double_by_cmd(cmd, type.to_sym => output)
 end
 
-Given /^a double of "([^"]*)" with exit status (\d+)$/ do |file, exit|
-  create_double(file, :exit_status => exit.to_i)
+Given /^I could run `([^`]*)` with exit status (\d+)$/ do |cmd, exit|
+  create_double_by_cmd(cmd, :exit_status => exit.to_i)
 end
 
-Given /^a double of "([^"]*)" with exit status (\d+) and (stdout|stderr):$/ do |file, exit, stdout_stderr, output|
-  create_double(file, :exit_status => exit.to_i, stdout_stderr.to_sym => output)
+Given /^I could run `([^`]*)` with exit status (\d+) and (stdout|stderr):$/ do |cmd, exit, type, output|
+  create_double_by_cmd(cmd, :exit_status => exit.to_i, type.to_sym => output)
 end

data/lib/aruba-doubles/double.rb

@@ -0,0 +1,23 @@
+module ArubaDoubles
+  class Double
+    attr_reader :stdout, :stderr, :exit_status, :expectations
+    
+    def initialize(expectations = {})
+      @expectations = expectations
+    end
+    
+    def could_receive(args, options = {})
+      args = args.join(' ') if args.respond_to?(:join)
+      @expectations[args] = options
+      self
+    end
+    
+    def run(argv = ARGV)
+      argv = argv.join(' ')
+      raise "Unexpected arguments" unless @expectations.has_key?(argv)
+      @stdout = @expectations[argv][:stdout]
+      @stderr = @expectations[argv][:stderr]
+      @exit_status = @expectations[argv][:exit_status]
+    end
+  end
+end

data/lib/aruba-doubles/hooks.rb

@@ -1,8 +1,3 @@
 After do
   remove_doubles if doubled?
 end
-
-Before('@repeat_arguments') do
-  warn(%{\e[35m    The @repeat_arguments tag is deprecated and will soon be removed. Please use the new mock feature to check for arguments (see README)!\e[0m})
-  @repeat_arguments = true
-end

data/spec/aruba-doubles/double_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe ArubaDoubles::Double, '#could_receive' do
+  before do
+    @double = ArubaDoubles::Double.new
+  end
+
+  it "should set expected arguments" do
+    @double.could_receive("--foo", :stdout => "foo")
+    @double.could_receive("--bar", :stdout => "bar")
+    @double.run(["--foo"])
+    @double.stdout.should eql("foo")
+    @double.run(["--bar"])
+    @double.stdout.should eql("bar")
+  end
+
+  it "should accept expected arguments as array" do
+    @double.could_receive(["--foo"], :stdout => "foo")
+    @double.could_receive(["--bar"], :stdout => "bar")
+    @double.run(["--foo"])
+    @double.stdout.should eql("foo")
+    @double.run(["--bar"])
+    @double.stdout.should eql("bar")
+  end
+
+  it "should return self" do
+    @double.could_receive("").should be(@double)
+  end
+  
+  it "should set defaults when called without options" do
+    @double.could_receive("")
+    @double.run([])
+    @double.stdout.should be_nil
+    @double.stderr.should be_nil
+    @double.exit_status.should be_nil
+  end
+
+  it "should set optional stdout" do
+    @double.could_receive("", :stdout => "hi")
+    @double.run([])
+    @double.stdout.should eql("hi")
+  end
+
+  it "should set optional stderr" do
+    @double.could_receive("", :stderr => "HO!")
+    @double.run([])
+    @double.stderr.should eql("HO!")
+  end
+  
+  it "should set optional exit status" do
+    @double.could_receive("", :exit_status => 1)
+    @double.run([])
+    @double.exit_status.should eql(1)
+  end
+end
+
+describe ArubaDoubles::Double, '#run' do
+  before do
+    @double = ArubaDoubles::Double.new
+  end
+  
+  it "should read ARGV by default" do
+    original_arguments = ARGV
+    ARGV = ["--foo"]
+    @double.could_receive("--foo", :stdout => "foo")
+    @double.run
+    @double.stdout.should eql("foo")
+    ARGV = original_arguments
+  end
+  
+  it "should raise when called with unexpected arguments" do
+    lambda {
+      @double.run(["--unexpected"])
+    }.should raise_error("Unexpected arguments")
+  end
+end
+
+describe ArubaDoubles::Double do
+  it "should be serializable" do
+    double = ArubaDoubles::Double.new
+    double.could_receive("")
+    double.could_receive("--foo", :stdout=>"foo")
+    double.could_receive("--bar", :stderr=>"OOPS!", :exit_status=>255)
+    loaded_double = ArubaDoubles::Double.new(double.expectations)
+    loaded_double.run([])
+    loaded_double.stdout.should be_nil
+    loaded_double.stderr.should be_nil
+    loaded_double.exit_status.should be_nil
+    loaded_double.run(["--foo"])
+    loaded_double.stdout.should eql("foo")
+    loaded_double.stderr.should be_nil
+    loaded_double.exit_status.should be_nil
+    loaded_double.run(["--bar"])
+    loaded_double.stdout.should be_nil
+    loaded_double.stderr.should eql("OOPS!")
+    loaded_double.exit_status.should eql(255)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'aruba-doubles/double'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: aruba-doubles
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - "Bj\xC3\xB6rn Albers"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-21 00:00:00 Z
+date: 2011-11-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: cucumber
@@ -49,6 +49,38 @@ dependencies:
         version: 0.4.6
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard-cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 7
+        - 3
+        version: 0.7.3
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 5
+        - 1
+        version: 0.5.1
+  type: :development
+  version_requirements: *id004
 description: Stub command line applications with Cucumber
 email: 
 - bjoernalbers@googlemail.com
@@ -61,18 +93,22 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - aruba-doubles.gemspec
-- features/double_cli_apps.feature
+- features/double.feature
 - features/environment-friendly.feature
 - features/step_definitions/dev_steps.rb
 - features/support/env.rb
 - lib/aruba-doubles.rb
 - lib/aruba-doubles/api.rb
 - lib/aruba-doubles/cucumber.rb
+- lib/aruba-doubles/double.rb
 - lib/aruba-doubles/hooks.rb
+- spec/aruba-doubles/double_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/bjoernalbers/aruba-doubles
 licenses: []
 
@@ -105,9 +141,11 @@ rubyforge_project:
 rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
-summary: aruba-doubles-0.1.1
+summary: aruba-doubles-0.2.0
 test_files: 
-- features/double_cli_apps.feature
+- features/double.feature
 - features/environment-friendly.feature
 - features/step_definitions/dev_steps.rb
 - features/support/env.rb
+- spec/aruba-doubles/double_spec.rb
+- spec/spec_helper.rb

data/features/double_cli_apps.feature

@@ -1,104 +0,0 @@
-Feature: Double command line applications
-
-	In order to double command line applications
-	As a developer using Cucumber
-	I want to use the "double of" steps
-
-	Scenario: Double default behaviour
-		Given a double of "foo"
-		When I run `foo`
-		Then the exit status should be 0
-		And the stdout should contain exactly:
-			"""
-			"""			
-		And the stderr should contain exactly:
-			"""
-			"""
-
-	Scenario: Double with stdout
-		Given a double of "foo" with stdout:
-			"""
-			hello, world.
-			"""
-		When I successfully run `foo`
-		Then the stdout should contain exactly:
-			"""
-			hello, world.
-			
-			"""
-		And the stderr should contain exactly:
-			"""
-			"""
-
-	 Scenario: Double with stderr
-	 	Given a double of "foo" with stderr:
-	 		"""
-	 		error: something crashed!
-	 		"""
-	 	When I successfully run `foo`
-	 	And the stdout should contain exactly:
-	 		"""
-	 		"""
-	 	Then the stderr should contain exactly:
-	 		"""
-	 		error: something crashed!
-   
-	 		"""
-
-	Scenario: Double with exit status
-		Given a double of "foo" with exit status 255
-		When I run `foo`
-		Then the exit status should be 255
-		And the stdout should contain exactly:
-			"""
-			"""			
-		And the stderr should contain exactly:
-			"""
-			"""
-
-	Scenario: Double with exit status and stdout
-		Given a double of "foo" with exit status 255 and stdout:
-			"""
-			hello, world.
-			"""
-		When I run `foo`
-		Then the exit status should be 255
-		And the stdout should contain exactly:
-			"""
-			hello, world.
-			
-			"""			
-		And the stderr should contain exactly:
-			"""
-			"""
-
-	Scenario: Double with expected arguments
-		Given a double of "foo --bar baz" with stdout:
-			"""
-			hello, world.
-			"""
-		When I run `foo`
-		Then the exit status should not be 0
-		And the stdout should contain exactly:
-			"""
-			"""
-		And the stderr should contain exactly:
-			"""
-			expected: foo --bar baz
-			     got: foo 
-			
-			"""
-			
-
-	@repeat_arguments
-	Scenario: Double with repeating arguments
-		Given a double of "foo"
-		When I run `foo`
-		Then the stdout should contain exactly:
-			"""
-			foo
-			
-			"""
-		And the stderr should contain exactly:
-			"""
-			"""