aruba-doubles 0.2.3 → 1.0.0

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+vendor/*
+tmp/*

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.2-p290

data/README.md

@@ -1,14 +1,36 @@
 # Aruba-Doubles
 
-Stub and mock command line applications with Cucumber
+Cucumber Steps to double Command Line Applications
 
 ## Introduction
 
-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: Aruba-Doubles is not an official part of Aruba but a good companion in the same domain, hence the name.)
+> Sometimes it is just plain hard to test the system under test (SUT)
+> because it depends on other components that cannot be used in the test
+> environment. This could be because they aren't available, they will not
+> return the results needed for the test or because executing them would
+> have undesirable side effects. In other cases, our test strategy
+> requires us to have more control or visibility of the internal behavior
+> of the SUT.
+> 
+> When we are writing a test in which we cannot (or chose not to) use a
+> real depended-on component (DOC), we can replace it with a Test Double.
+> The Test Double doesn't have to behave exactly like the real DOC; it
+> merely has to provide the same API as the real one so that the SUT
+> thinks it is the real one!
+>
+> &mdash; <cite>[Gerard Meszaros, *xUnit Test Patterns: Refactoring Test
+> Code*, Copyright © 2007, Addison-Wesley, ISBN
+> 978-0131495050.](http://xunitpatterns.com/Test%20Double.html)</cite>
+
+Aruba-Doubles is a [Cucumber](http://cukes.info/) extention to
+temporarily "replace" selected Command Line Applications by Test
+Doubles.
+This allows you to simply stub them or fake their output depending on
+ARGV.
+
+(Aruba-Doubles is not an official part of
+[Aruba](https://github.com/cucumber/aruba) but a good companion in the
+same domain, hence the name.)
 
 ## Usage
 
@@ -16,61 +38,43 @@ If you have a `Gemfile`, add `aruba-doubles`. Otherwise, install it like this:
 
     gem install aruba-doubles
 
-Then, `require` the library in one of your ruby files under `features/support` (e.g. `env.rb`)
-
-    require 'aruba-doubles/cucumber'
-
-### Stubbing
+Then, `require` the [step
+definitions](https://github.com/bjoernalbers/aruba-doubles/blob/master/lib/aruba-doubles/cucumber.rb)
+in a ruby files below `features/support` (e.g. `env.rb`):
 
-You can stub commands by using the `I could run` steps:
+```Ruby
+require 'aruba-doubles/cucumber'
+```
 
-	Background:
-		Given I could run `kill_the_cat` with stdout:
-			"""
-			R.I.P.
-			"""
+This file contains all [step
+definitions](https://github.com/bjoernalbers/aruba-doubles/blob/master/lib/aruba-doubles/cucumber.rb),
+so you might wanna have a look at it.
+Usage examples can be found in the
+[features](https://github.com/bjoernalbers/aruba-doubles/tree/master/features)
+directory.
 
-	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
+## How it works
 
-	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"
+Aruba-Doubles does the following:
 
-	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..."
+1. Hijack the PATH variable by injecting a temporary doubles directory
+   in front of it.
+2. Create Test Doubles (which are executable Ruby scripts) inside the
+   doubles directory.
+3. Restore the old PATH and remove all Test Doubles  after each
+   scenario.
 
-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!).
+This way your SUT will pick up the Test Double instead of the real
+Command Line Application.
 
 ## Caveats
 
-Aruba-Double won't work, if your command...
+Aruba-Double won't work, if your command:
 
 * calls other commands with absolute path, i.e. `/usr/local/kill_the_cat`
 * 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
@@ -85,4 +89,4 @@ Also note that doubles will be created as scripts in temporary directories on yo
 
 ## Copyright
 
-Copyright (c) 2011 Björn Albers. See LICENSE for details.
+Copyright (c) 2011-2012 Björn Albers. See LICENSE for details.

data/aruba-doubles.gemspec

@@ -2,15 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name        = 'aruba-doubles'
-  s.version     = '0.2.3'
-  s.authors     = ["Björn Albers"]
-  s.email       = ["bjoernalbers@googlemail.com"]
-  s.description = 'Stub command line applications with Cucumber'
+  s.version     = '1.0.0'
+  s.authors     = ['Björn Albers']
+  s.email       = ['bjoernalbers@googlemail.com']
+  s.description = 'Cucumber Steps to double Command Line Applications'
   s.summary     = "#{s.name}-#{s.version}"
   s.homepage    = "https://github.com/bjoernalbers/#{s.name}"
 
   s.add_dependency 'cucumber', '>= 1.0.2'
+  s.add_dependency 'rspec', '>= 2.6.0'
 
+  s.add_development_dependency 'rake', '>= 0.9.2.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'
@@ -18,5 +20,5 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 end

data/features/define_output.feature

@@ -0,0 +1,92 @@
+Feature: Define Output
+
+  In order to double a command line application
+  As a BDD-guy
+  I want to define the doubles output
+
+  Scenario: Double with default stdout, stderr and exit status
+    Given I double `foo --bar baz`
+    When I run `foo --bar baz`
+    Then the exit status should be 0
+    And the stdout should be empty
+    And the stderr should be empty
+
+  Scenario: Double with custom stdout (inline)
+    Given I double `foo` with "hello, world."
+    When I run `foo`
+    Then the exit status should be 0
+    And the stdout should contain "hello, world."
+    And the stderr should be empty
+
+  Scenario: Double with custom stdout
+    Given I double `foo --bar baz` with stdout:
+      """
+      hello, world.
+      """
+    When I run `foo --bar baz`
+    Then the exit status should be 0
+    And the stdout should contain exactly:
+      """
+      hello, world.
+
+      """
+    And the stderr should be empty
+
+  Scenario: Double with custom stdout and exit status
+    Given I double `foo --bar baz` with exit status 42 and stdout:
+      """
+      hello, world.
+      """
+    When I run `foo --bar baz`
+    Then the exit status should be 42
+    And the stdout should contain exactly:
+      """
+      hello, world.
+
+      """
+    And the stderr should be empty
+
+  Scenario: Double with custom stderr
+    Given I double `foo --bar baz` with stderr:
+      """
+      BOOOOOOOM!!!
+      """
+    When I run `foo --bar baz`
+    Then the exit status should be 0
+    And the stdout should be empty
+    And the stderr should contain exactly:
+      """
+      BOOOOOOOM!!!
+
+      """
+
+  Scenario: Double with custom stderr and exit status
+    Given I double `foo --bar baz` with exit status 42 and stderr:
+      """
+      BOOOOOOOM!!!
+      """
+    When I run `foo --bar baz`
+    Then the exit status should be 42
+    And the stdout should be empty
+    And the stderr should contain exactly:
+      """
+      BOOOOOOOM!!!
+
+      """
+
+  Scenario: Double with custom exit status
+    Given I double `foo --bar baz` with exit status 42
+    When I run `foo --bar baz`
+    Then the exit status should be 42
+    And the stdout should be empty
+    And the stderr should be empty
+
+  Scenario: Double called with unknown arguments
+    Given I double `foo --bar baz` with exit status 42 and stdout:
+      """
+      hello, world.
+      """
+    When I run `foo --unknown arguments`
+    Then the exit status should be 0
+    And the stdout should be empty
+    And the stderr should be empty

data/features/double_commands.feature

@@ -0,0 +1,35 @@
+Feature: Double Commands
+
+  In order to avoid that my system-under-test runs certain commands
+  As a BDD-guy
+  I want to double command line applications
+
+  Background:
+    Given a file named "foo" with:
+      """
+      #!/usr/bin/env ruby
+      puts "stdout of foo"
+      warn "stderr of foo"
+      exit 5
+      """
+    And I run `chmod +x foo`
+    And I append the current working dir to my path
+
+  Scenario: Run the original (undoubled) command
+    When I run `foo`
+    Then the exit status should be 5
+    And the stdout should contain "stdout of foo"
+    And the stderr should contain "stderr of foo"
+
+  Scenario: Double and run the command
+    Given I double `foo`
+    When I run `foo`
+    Then the exit status should be 0
+    And the stdout should not contain "stdout of foo"
+    And the stderr should not contain "stderr of foo"
+
+  Scenario: Run the original (undoubled) command
+    When I run `foo`
+    Then the exit status should be 5
+    And the stdout should contain "stdout of foo"
+    And the stderr should contain "stderr of foo"

data/features/step_definitions/dev_steps.rb

@@ -1,21 +1,5 @@
-Then /^the doubles directory should not exist$/ do
-  @doubles_dir.should be_nil
-end
-
-Then /^the path should include (\d+) doubles directory$/ do |count|
-  ENV['PATH'].split(File::PATH_SEPARATOR).count(@doubles_dir).should eql(count.to_i)
-end
-
-When /^I keep the doubles directory in mind$/ do
-  @@previous_doubles_dir = @doubles_dir
-end
-
-Then /^the previous doubles directory should not exist$/ do
-  File.should_not be_exist(@@previous_doubles_dir)
-end
-
-Then /^the previous doubles directory should exist$/ do
-  File.should be_exist(@@previous_doubles_dir)
+Given /^I append the current working dir to my path$/ do
+  ENV['PATH'] = [ENV['PATH'], '.'].join(File::PATH_SEPARATOR)
 end
 
 Then /^the (stdout|stderr) should be empty$/ do |stdout_stderr|
@@ -25,5 +9,3 @@ Then /^the (stdout|stderr) should be empty$/ do |stdout_stderr|
 			"""
   }
 end
-
-

data/lib/aruba-doubles/cucumber.rb

@@ -1,20 +1,39 @@
-require 'aruba-doubles/hooks'
-require 'aruba-doubles/api'
+require 'aruba-doubles'
 
-World(ArubaDoubles::Api)
+World(ArubaDoubles)
 
-Given /^I could run `([^`]*)`$/ do |cmd|
-  create_double_by_cmd(cmd)
+Before do
+  ArubaDoubles::Double.setup
 end
 
-Given /^I could run `([^`]*)` with (stdout|stderr):$/ do |cmd, type, output|
-  create_double_by_cmd(cmd, type.to_sym => output)
+After do
+  ArubaDoubles::Double.teardown
 end
 
-Given /^I could run `([^`]*)` with exit status (\d+)$/ do |cmd, exit|
-  create_double_by_cmd(cmd, :exit_status => exit.to_i)
+Given /^I double `([^`]*)`$/ do |cmd|
+  double_cmd(cmd)
 end
 
-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)
+Given /^I double `([^`]*)` with "([^"]*)"$/ do |cmd, stdout|
+  double_cmd(cmd, :puts => stdout)
+end
+
+Given /^I double `([^`]*)` with stdout:$/ do |cmd, stdout|
+  double_cmd(cmd, :puts => stdout)
+end
+
+Given /^I double `([^`]*)` with exit status (\d+) and stdout:$/ do |cmd, exit_status, stdout|
+  double_cmd(cmd, :puts => stdout, :exit => exit_status.to_i)
+end
+
+Given /^I double `([^`]*)` with stderr:$/ do |cmd, stderr|
+  double_cmd(cmd, :warn => stderr)
+end
+
+Given /^I double `([^`]*)` with exit status (\d+) and stderr:$/ do |cmd, exit_status, stderr|
+  double_cmd(cmd, :warn => stderr, :exit => exit_status.to_i)
+end
+
+Given /^I double `([^`]*)` with exit status (\d+)$/ do |cmd, exit_status|
+  double_cmd(cmd, :exit => exit_status.to_i)
 end

data/lib/aruba-doubles/double.rb

@@ -1,29 +1,141 @@
 module ArubaDoubles
   class Double
-    attr_reader :stdout, :stderr, :exit_status, :expectations
-    
-    def self.run!(expectations = {})
-      double = self.new(expectations)
-      double.run
-      puts double.stdout if double.stdout
-      warn double.stderr if double.stderr
-      exit(double.exit_status) if double.exit_status
+    class << self
+
+      # Setup the doubles environment.
+      def setup
+        patch_path
+      end
+
+      # Teardown the doubles environment.
+      def teardown
+        delete_all
+        restore_path
+      end
+
+      # Initialize and create a new double.
+      #
+      # It accepts an optional block to setup define the doubles output.
+      def create(filename, &block)
+        double = new(filename)
+        double.instance_eval(&block) if block_given?
+        double.create
+      end
+
+      # Initialize and run a new double.
+      #
+      # It accepts an optional block to setup define the doubles output.
+      def run(&block)
+        double = new(File.basename($PROGRAM_NAME))
+        double.instance_eval(&block) if block_given?
+        double.run
+      end
+
+      # Return the doubles directory.
+      # @return [String]
+      def bindir
+        @bindir ||= Dir.mktmpdir
+      end
+
+      # Iterate over all registered doubles.
+      def each
+        all.each { |double| yield(double) }
+      end
+
+      # Return all registered doubles.
+      # @return [Array<ArubaDoubles::Double>]
+      def all
+        @doubles ||= []
+      end
+
+    private
+
+      attr_reader :original_path
+
+      # Delete all registered doubles.
+      def delete_all
+        each(&:delete)
+      end
+
+      # Prepend doubles directory to PATH.
+      def patch_path
+        unless bindir_in_path?
+          @original_path = ENV['PATH']
+          ENV['PATH'] = [bindir, ENV['PATH']].join(File::PATH_SEPARATOR)
+        end
+      end
+
+      # Remove doubles directory from PATH.
+      def restore_path
+        ENV['PATH'] = original_path if bindir_in_path?
+      end
+
+      # Check if PATH is already patched.
+      # @return [Boolean]
+      def bindir_in_path?
+        ENV['PATH'].split(File::PATH_SEPARATOR).first == bindir
+      end
     end
-    
-    def initialize(expectations = {})
-      @expectations = expectations
+
+    attr_reader   :filename, :output, :matchers
+
+    # Instantiate and register new double.
+    # @return [ArubaDoubles::Double]
+    def initialize(cmd, default_output = {}, &block)
+      @filename = cmd
+      @output = {:puts => nil, :warn => nil, :exit => nil}.merge(default_output)
+      @matchers = []
+      self.class.all << self
+      self.instance_eval(&block) if block_given?
     end
-    
-    def could_receive(args, options = {})
-      @expectations[args] = options
-      self
+
+    # Add ARGV matcher with output.
+    def on(argv, output = nil)
+      @matchers << [argv, output || default_output]
     end
-    
+
+    # Run the double.
+    #
+    # This will actually display any outputs if defined and exit.
     def run(argv = ARGV)
-      raise "Unexpected arguments: #{argv.inspect}" unless @expectations.has_key?(argv)
-      @stdout = @expectations[argv][:stdout]
-      @stderr = @expectations[argv][:stderr]
-      @exit_status = @expectations[argv][:exit_status]
+      @matchers.each do |m|
+        expected_argv, output = *m
+        @output = output if argv == expected_argv
+      end
+      puts @output[:puts] if @output[:puts]
+      warn @output[:warn] if @output[:warn]
+      exit @output[:exit] if @output[:exit]
+    end
+
+    # Create the executable double.
+    # @return [String] full path to the double.
+    def create
+      content = self.to_ruby
+      fullpath = File.join(self.class.bindir, filename)
+      #puts "creating double: #{fullpath} with content:\n#{content}" # debug
+      f = File.open(fullpath, 'w')
+      f.puts content
+      f.close
+      FileUtils.chmod(0755, File.join(self.class.bindir, filename))
+    end
+
+    # Export the double to executable Ruby code.
+    #
+    # @return [String] serialized double
+    def to_ruby
+      ruby = ['#!/usr/bin/env ruby']
+      ruby << "$: << '#{File.expand_path('..', File.dirname(__FILE__))}'"
+      ruby << 'require "aruba-doubles"'
+      ruby << 'ArubaDoubles::Double.run do'
+      @matchers.each { |argv,output| ruby << "  on #{argv.inspect}, #{output.inspect}" }
+      ruby << 'end'
+      ruby.join("\n")
+    end
+
+    # Delete the executable double.
+    def delete
+      fullpath = File.join(self.class.bindir, filename)
+      FileUtils.rm(fullpath) if File.exists?(fullpath)
     end
   end
 end

data/lib/aruba-doubles.rb

@@ -1 +1,12 @@
-# Load nothing - just keep the file here to keep bundler happy.
+require 'tempfile'
+require 'shellwords'
+require 'aruba-doubles/double'
+
+module ArubaDoubles
+  def double_cmd(cmd, output = {})
+   argv = Shellwords.split(cmd)
+   Double.create(argv.shift) do
+     on(argv, output)
+   end
+  end
+end

data/spec/aruba-doubles/double_spec.rb

@@ -1,89 +1,249 @@
 require 'spec_helper'
 
-describe ArubaDoubles::Double, '#could_receive' do
-  before do
-    @double = ArubaDoubles::Double.new
-  end
+describe ArubaDoubles::Double do
+  describe '.setup' do
+    before do
+      @original_path = ENV['PATH']
+      @bindir = '/tmp/foo'
+      ArubaDoubles::Double.stub(:bindir).and_return(@bindir)
+    end
+
+    after do
+      ENV['PATH'] = @original_path
+    end
 
-  it "should set expected arguments like ARGV" 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")
+    it 'should prepend the doubles directory to PATH' do
+      ENV['PATH'].should_not match(%r(^#{@bindir}))
+      ArubaDoubles::Double.setup
+      ENV['PATH'].should match(%r(^#{@bindir}))
+    end
+
+    it 'should change the path only once' do
+      ArubaDoubles::Double.setup
+      ArubaDoubles::Double.setup
+      ENV['PATH'].scan(@bindir).count.should eq(1)
+    end
   end
 
-  it "should return self" do
-    @double.could_receive([]).should be(@double)
+  describe '.bindir' do
+    it 'should create and return the temporary doubles directory' do
+      bindir = '/tmp/foo'
+      Dir.should_receive(:mktmpdir).once.and_return(bindir)
+      ArubaDoubles::Double.bindir.should eq(bindir)
+      ArubaDoubles::Double.bindir.should eq(bindir)
+    end
   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
+
+  describe '.teardown' do
+    before do
+      @bindir = '/tmp/foo'
+    end
+
+    it 'should delete all registered doubles' do
+      doubles = []
+      3.times { |i| doubles << double(i) }
+      doubles.map{ |d| d.should_receive(:delete) }
+      ArubaDoubles::Double.should_receive(:all).and_return(doubles)
+      ArubaDoubles::Double.teardown
+    end
+
+    it 'should remove the doubles dir'
+    it 'should not remove a non-empty doubles dir'
+
+    it 'should remove the doubles dir from PATH' do
+      ArubaDoubles::Double.stub(:bindir).and_return(@bindir)
+      ArubaDoubles::Double.setup
+      ENV['PATH'].should match(%r(^#{@bindir}))
+      ArubaDoubles::Double.teardown
+      ENV['PATH'].should_not match(%r(^#{@bindir}))
+    end
+
+    it 'should not restore PATH when unchanged' do
+      original_path = '/foo:/bar:/baz'
+      ArubaDoubles::Double.stub(:original_path).and_return('/foo:/bar:/baz')
+      ArubaDoubles::Double.teardown
+      ENV['PATH'].should_not eq(original_path)
+    end
   end
 
-  it "should set optional stdout" do
-    @double.could_receive([], :stdout => "hi")
-    @double.run([])
-    @double.stdout.should eql("hi")
+  describe '.new' do
+    it 'should register the double' do
+      d = ArubaDoubles::Double.new('bar')
+      ArubaDoubles::Double.all.should include(d)
+    end
+
+    it 'should initialize all output attributes with nil' do
+      output = ArubaDoubles::Double.new('foo').output
+      output.should eql({:puts => nil, :warn => nil, :exit => nil})
+    end
+
+    it 'should execute a given block in the doubles context' do
+      double = ArubaDoubles::Double.new('bar') { def hi; "hi" end }
+      double.should respond_to(:hi)
+    end
+
+    it 'should raise error on missing filename'
+    it 'should raise error on absolute filename'
   end
 
-  it "should set optional stderr" do
-    @double.could_receive([], :stderr => "HO!")
-    @double.run([])
-    @double.stderr.should eql("HO!")
+  describe '.run' do
+    before do
+      @double = double('double', :run => nil)
+      ArubaDoubles::Double.stub(:new).and_return(@double)
+    end
+
+    it 'should initialize a new double with the program name' do
+      ArubaDoubles::Double.should_receive(:new).with('rspec')
+      ArubaDoubles::Double.run
+    end
+
+    it 'should execute a block on that double when given' do
+      block = Proc.new {}
+      @double.should_receive(:instance_eval).with(&block)
+      ArubaDoubles::Double.run(&block)
+    end
+
+    it 'should run the double' do
+      @double.should_receive(:run)
+      ArubaDoubles::Double.run
+    end
   end
-  
-  it "should set optional exit status" do
-    @double.could_receive([], :exit_status => 1)
-    @double.run([])
-    @double.exit_status.should eql(1)
+
+  describe '#run' do
+    before do
+      @double = ArubaDoubles::Double.new('foo',
+        :puts => 'default stdout',
+        :warn => 'default stderr',
+        :exit => 23)
+      @double.on %w[--hello],
+        :puts => 'hello, world.',
+        :warn => 'BOOOOM!',
+        :exit => 42
+      @double.stub(:puts => nil, :warn => nil, :exit => nil)
+    end
+
+    context 'when ARGV does match' do
+      def run_double
+        @double.run %w[--hello]
+      end
+
+      it 'should print given stdout' do
+        @double.should_receive(:puts).with('hello, world.')
+        run_double
+      end
+
+      it 'should print given stderr' do
+        @double.should_receive(:warn).with('BOOOOM!')
+        run_double
+      end
+
+      it 'should return given exit code' do
+        @double.should_receive(:exit).with(42)
+        run_double
+      end
+    end
+
+    context 'when ARGV does not match' do
+      def run_double
+        @double.run %w[--these --arguments --do --not --match]
+      end
+
+      it 'should print default stdout' do
+        @double.should_receive(:puts).with('default stdout')
+        run_double
+      end
+
+      it 'should print no stderr' do
+        @double.should_receive(:warn).with('default stderr')
+        run_double
+      end
+
+      it 'should exit with zero' do
+        @double.should_receive(:exit).with(23)
+        run_double
+      end
+    end
+
+    it 'should read ARGV'
   end
-end
 
-describe ArubaDoubles::Double, '#run' do
-  before do
-    @double = ArubaDoubles::Double.new
+  describe '.create' do
+    before do
+      @double = double('double', :create => nil)
+      ArubaDoubles::Double.stub(:new).and_return(@double)
+    end
+
+    it 'should initialize a new double with the program name' do
+      ArubaDoubles::Double.should_receive(:new).with('foo')
+      ArubaDoubles::Double.create('foo')
+    end
+
+    it 'should execute a block on that double when given' do
+      block = Proc.new {}
+      @double.should_receive(:instance_eval).with(&block)
+      ArubaDoubles::Double.create('foo', &block)
+    end
+
+    it 'should create the double' do
+      @double.should_receive(:create)
+      ArubaDoubles::Double.create('foo')
+    end
+
+    it 'should return the new double'
   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
+
+  describe '#create' do
+    it 'should create the executable command inside the doubles dir' do
+      file = double('file', :puts => nil, :close => nil)
+      ArubaDoubles::Double.stub(:bindir).and_return('/tmp/foo')
+      File.should_receive(:open).with('/tmp/foo/bar', 'w').and_return(file)
+      FileUtils.stub(:chmod)
+      ArubaDoubles::Double.new('bar').create
+    end
+
+    it 'should make the file executable' do
+      ArubaDoubles::Double.stub(:bindir).and_return('/tmp/foo')
+      File.stub(:open).and_return(stub(:puts => nil, :close => nil))
+
+      filename = '/tmp/foo/bar'
+      FileUtils.should_receive(:chmod).with(0755, filename)
+
+      ArubaDoubles::Double.new('bar').create
+    end
   end
-  
-  it "should raise when called with unexpected arguments" do
-    lambda {
-      @double.run(["--unexpected"])
-    }.should raise_error('Unexpected arguments: ["--unexpected"]')
+
+  describe '#to_ruby' do
+    before do
+      @double = ArubaDoubles::Double.new('foo')
+    end
+
+    it 'should start with a she-bang line' do
+      @double.to_ruby.should include('#!/usr/bin/env ruby')
+    end
+
+    it 'should require the libs' do
+      @double.to_ruby.should include('require "aruba-doubles"')
+    end
+
+    it 'should include the doubles boilerplate' do
+      @double.to_ruby.should match(/^ArubaDoubles::Double.run\s+do.*end$/m)
+    end
+
+    it 'should include the defined outputs' do
+      @double.on %w(--foo), :puts => 'bar'
+      @double.to_ruby.should include('on ["--foo"], {:puts=>"bar"}')
+    end
+
+    it 'should not include a block when no output is defined'
   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)
+  describe '#delete' do
+    it 'should delete the executable file if it exists' do
+      ArubaDoubles::Double.stub(:bindir).and_return('/tmp/foo')
+      double = ArubaDoubles::Double.new('bar')
+      File.should_receive(:exists?).with('/tmp/foo/bar').and_return(true)
+      FileUtils.should_receive(:rm).with('/tmp/foo/bar')
+      double.delete
+    end
   end
 end

data/spec/spec_helper.rb

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

metadata

@@ -1,97 +1,91 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: aruba-doubles
-version: !ruby/object:Gem::Version 
-  hash: 17
+version: !ruby/object:Gem::Version
+  version: 1.0.0
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 3
-  version: 0.2.3
 platform: ruby
-authors: 
-- "Bj\xC3\xB6rn Albers"
+authors:
+- Björn Albers
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-03-19 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-04-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: cucumber
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70348087415700 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 1
-        - 0
-        - 2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.2
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: aruba
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70348087415700
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70348087413900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70348087413900
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70348087413220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *70348087413220
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: &70348087412140 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        - 4
-        - 6
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.4.6
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: guard-cucumber
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70348087412140
+- !ruby/object:Gem::Dependency
+  name: guard-cucumber
+  requirement: &70348087411000 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 0
-        - 7
-        - 3
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.7.3
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: guard-rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *70348087411000
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70348087410280 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 0
-        - 5
-        - 1
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.5.1
   type: :development
-  version_requirements: *id004
-description: Stub command line applications with Cucumber
-email: 
+  prerelease: false
+  version_requirements: *70348087410280
+description: Cucumber Steps to double Command Line Applications
+email:
 - bjoernalbers@googlemail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .rbenv-version
 - .rvmrc
 - Gemfile
 - Guardfile
@@ -99,55 +93,49 @@ files:
 - README.md
 - Rakefile
 - aruba-doubles.gemspec
-- features/double.feature
-- features/environment-friendly.feature
+- features/define_output.feature
+- features/double_commands.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: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 2074239273219406016
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: 2074239273219406016
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: aruba-doubles-0.2.3
-test_files: 
-- features/double.feature
-- features/environment-friendly.feature
+summary: aruba-doubles-1.0.0
+test_files:
+- features/define_output.feature
+- features/double_commands.feature
 - features/step_definitions/dev_steps.rb
 - features/support/env.rb
 - spec/aruba-doubles/double_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/features/double.feature

@@ -1,88 +0,0 @@
-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 'hello, world.'`
-		When I successfully run `foo --bar 'hello, world.'`
-		Then the stdout should be empty
-		And the stderr should be empty
-		When I run `foo --bar hello world`
-		Then the exit status should not be 0
-		And the stdout should be empty
-		And the stderr should contain:
-			"""
-			Unexpected arguments: ["--bar", "hello", "world"]
-			"""
-
-	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

@@ -1,29 +0,0 @@
-Feature: Environment-friendly
-
-	In order to not mess up my system or tests
-	As a developer using Cucumber
-	I want Aruba-Doubles to behave environment-friendly
-
-	Scenario: Create doubles directory only when necessary
-		When I run `ls`
-		Then the doubles directory should not exist
-
-	Scenario: Patch the original path only once
-		Given I could run `ls`
-		And I could run `ls`
-		Then the path should include 1 doubles directory
-
-	Scenario: Create doubles directory...
-		Given I could run `ls`
-		When I keep the doubles directory in mind
-	
-	Scenario: ...and check that it was deleted
-		Then the previous doubles directory should not exist
-
-	@no-clobber
-	Scenario: Create doubles directory...
-		Given I could run `ls`
-		When I keep the doubles directory in mind
-    
-	Scenario: ...and check that it was not deleted
-		Then the previous doubles directory should exist

data/lib/aruba-doubles/api.rb

@@ -1,73 +0,0 @@
-require 'aruba-doubles/double'
-require 'shellwords'
-
-module ArubaDoubles
-  module Api
-    def doubled?
-      !@doubles_dir.nil?
-    end
-    
-    def create_double_by_cmd(cmd, options = {})
-      arguments = Shellwords.split(cmd)
-      filename = arguments.shift
-      create_double(filename, arguments, options)
-    end
-    
-    def create_double(filename, arguments, options = {})
-      unless doubled?
-        create_doubles_dir
-        patch_original_path
-      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 'rubygems'"
-        f.puts "require 'cucumber' # Required for Ruby 1.8.7 (see issue #4)"
-        f.puts "require 'yaml'"
-        f.puts "require 'aruba-doubles/double'"
-        f.puts "ArubaDoubles::Double.run! YAML.load %Q{"
-        f.puts double.expectations.to_yaml
-        f.puts "}"
-      end
-      FileUtils.chmod(0755, fullpath)
-    end
-
-    def remove_doubles
-      restore_original_path
-      remove_doubles_dir
-    end
-
-  private
-
-    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 restore_original_path
-      ENV['PATH'] = @__aruba_doubles_original_path.join(File::PATH_SEPARATOR) unless doubled?
-    end
-
-    def remove_doubles_dir
-      FileUtils.rm_r(@doubles_dir) unless @doubles_dir.nil?
-    end
-  end
-end

data/lib/aruba-doubles/hooks.rb

@@ -1,3 +0,0 @@
-After('~@no-clobber') do
-  remove_doubles if doubled?
-end